<html devsite>
<head>
  <meta name="project_path" value="/_project.yaml">
  <meta name="book_path" value="/_book.yaml">
</head>
<body>

<h1 class="page-title">Command-Line Reference</h1>

{% dynamic setvar source_file "site/command-line-reference-prefix.html" %}
{% include "_buttons.html" %}

<pre>
bazel [&lt;startup options&gt;] &lt;command&gt; [&lt;args&gt;]
</pre>

or

<pre>
bazel [&lt;startup options&gt;] &lt;command&gt; [&lt;args&gt;] -- [&lt;target patterns&gt;]
</pre>

See the <a href="/docs/build#specifying-build-targets">User's Guide</a> for the
target patterns syntax.

<h2>Option Syntax</h2>

<p>
Options can be passed to Bazel in different ways. Options that require a value
can be passed with either an equals sign or a space:
<pre>
--&lt;option&gt;=&lt;value&gt;
--&lt;option&gt; &lt;value&gt;
</pre>
Some options have a single character short form; in that case, the short form
has to be passed with a single dash and a space.
<pre>
-&lt;short_form&gt; &lt;value&gt;
</pre>
</p>

<p>
Boolean options can be enabled as follows:
<pre>
--&lt;option&gt;
--&lt;option&gt;=[true|yes|1]
</pre>

and disabled as follows:
<pre>
--no&lt;option&gt;
--&lt;option&gt;=[false|no|0]
</pre>
</p>

<p>
Tristate options are usually set to automatic by default, and can be
force-enabled as follows:
<pre>
--&lt;option&gt;=[true|yes|1]
</pre>
or force-disabled as follows:
<pre>
--no&lt;option&gt;
--&lt;option&gt;=[false|no|0]
</pre>
</p>
<h2>Commands</h2>
<table>
<tr>
  <td><a href="#aquery"><code>aquery</code></a></td>
  <td>Analyzes the given targets and queries the action graph.</td>
</tr>
<tr>
  <td><a href="#build"><code>build</code></a></td>
  <td>Builds the specified targets.</td>
</tr>
<tr>
  <td><a href="#canonicalize-flags"><code>canonicalize-flags</code></a></td>
  <td>Canonicalizes a list of bazel options.</td>
</tr>
<tr>
  <td><a href="#clean"><code>clean</code></a></td>
  <td>Removes output files and optionally stops the server.</td>
</tr>
<tr>
  <td><a href="#coverage"><code>coverage</code></a></td>
  <td>Generates code coverage report for specified test targets.</td>
</tr>
<tr>
  <td><a href="#cquery"><code>cquery</code></a></td>
  <td>Loads, analyzes, and queries the specified targets w/ configurations.</td>
</tr>
<tr>
  <td><a href="#dump"><code>dump</code></a></td>
  <td>Dumps the internal state of the bazel server process.</td>
</tr>
<tr>
  <td><a href="#fetch"><code>fetch</code></a></td>
  <td>Fetches external repositories that are prerequisites to the targets.</td>
</tr>
<tr>
  <td><a href="#help"><code>help</code></a></td>
  <td>Prints help for commands, or the index.</td>
</tr>
<tr>
  <td><a href="#info"><code>info</code></a></td>
  <td>Displays runtime info about the bazel server.</td>
</tr>
<tr>
  <td><a href="#license"><code>license</code></a></td>
  <td>Prints the license of this software.</td>
</tr>
<tr>
  <td><a href="#mobile-install"><code>mobile-install</code></a></td>
  <td>Installs targets to mobile devices.</td>
</tr>
<tr>
  <td><a href="#mod"><code>mod</code></a></td>
  <td>Queries the Bzlmod external dependency graph</td>
</tr>
<tr>
  <td><a href="#print_action"><code>print_action</code></a></td>
  <td>Prints the command line args for compiling a file.</td>
</tr>
<tr>
  <td><a href="#query"><code>query</code></a></td>
  <td>Executes a dependency graph query.</td>
</tr>
<tr>
  <td><a href="#run"><code>run</code></a></td>
  <td>Runs the specified target.</td>
</tr>
<tr>
  <td><a href="#shutdown"><code>shutdown</code></a></td>
  <td>Stops the bazel server.</td>
</tr>
<tr>
  <td><a href="#test"><code>test</code></a></td>
  <td>Builds and runs the specified test targets.</td>
</tr>
<tr>
  <td><a href="#vendor"><code>vendor</code></a></td>
  <td>Fetches external repositories into a folder specified by the flag --vendor_dir.</td>
</tr>
<tr>
  <td><a href="#version"><code>version</code></a></td>
  <td>Prints version information for bazel.</td>
</tr>
</table>

<h2>Startup Options</h2>
<dl>Options that appear before the command and are parsed by the client:
<dt id="startup_options-flag--autodetect_server_javabase"><code id="autodetect_server_javabase"><a href="#startup_options-flag--autodetect_server_javabase">--[no]autodetect_server_javabase</a></code> default: "true"</dt>
<dd>
<p>When --noautodetect_server_javabase is passed, Bazel does not fall back to the local JDK for running the bazel server and instead exits.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="startup_options-flag--batch"><code id="batch"><a href="#startup_options-flag--batch">--[no]batch</a></code> default: "false"</dt>
<dd>
<p>If set, Bazel will be run as just a client process without a server, instead of in the standard client/server mode. This is deprecated and will be removed, please prefer shutting down the server explicitly if you wish to avoid lingering servers.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>, <a href="#metadata_tag_DEPRECATED"><code>deprecated</code></a>
</p></dd>
<dt id="startup_options-flag--batch_cpu_scheduling"><code id="batch_cpu_scheduling"><a href="#startup_options-flag--batch_cpu_scheduling">--[no]batch_cpu_scheduling</a></code> default: "false"</dt>
<dd>
<p>Only on Linux; use 'batch' CPU scheduling for Blaze. This policy is useful for workloads that are non-interactive, but do not want to lower their nice value. See 'man 2 sched_setscheduler'. If false, then Bazel does not perform a system call.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="startup_options-flag--bazelrc"><code id="bazelrc"><a href="#startup_options-flag--bazelrc">--bazelrc</a>=&lt;path&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The location of the user .bazelrc file containing default values of Bazel options.
<code>/dev/null</code> indicates that all further <code>--bazelrc</code>s will be ignored, which is useful to
disable the search for a user rc file, e.g. in release builds.</p>
<p>This option can also be specified multiple times. e.g. with
<code>--bazelrc=x.rc --bazelrc=y.rc --bazelrc=/dev/null --bazelrc=z.rc</code>.</p>
<ol>
<li><code>x.rc</code> and <code>y.rc</code> are read.</li>
<li><code>z.rc</code> is ignored due to the prior <code>/dev/null</code>.
If unspecified, Bazel uses the first <code>.bazelrc</code> file it finds in
the following two locations: the workspace directory, then the user's home
directory.</li>
</ol>
<p>Note: command line options will always supersede any option in bazelrc.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="startup_options-flag--block_for_lock"><code id="block_for_lock"><a href="#startup_options-flag--block_for_lock">--[no]block_for_lock</a></code> default: "true"</dt>
<dd>
<p>When --noblock_for_lock is passed, Bazel does not wait for a running command to complete, but instead exits immediately.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="startup_options-flag--client_debug"><code id="client_debug"><a href="#startup_options-flag--client_debug">--[no]client_debug</a></code> default: "false"</dt>
<dd>
<p>If true, log debug information from the client to stderr. Changing this option will not cause the server to restart.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="startup_options-flag--connect_timeout_secs"><code id="connect_timeout_secs"><a href="#startup_options-flag--connect_timeout_secs">--connect_timeout_secs</a>=&lt;an integer&gt;</code> default: "30"</dt>
<dd>
<p>The amount of time the client waits for each attempt to connect to the server</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="startup_options-flag--digest_function"><code id="digest_function"><a href="#startup_options-flag--digest_function">--digest_function</a>=&lt;hash function&gt;</code> default: see description</dt>
<dd>
<p>The hash function to use when computing file digests.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="startup_options-flag--experimental_cgroup_parent"><code id="experimental_cgroup_parent"><a href="#startup_options-flag--experimental_cgroup_parent">--experimental_cgroup_parent</a>=&lt;path&gt;</code> default: see description</dt>
<dd>
<p>The cgroup where to start the bazel server as an absolute path. The server process will be started in the specified cgroup for each supported controller. For example, if the value of this flag is /build/bazel and the cpu and memory controllers are mounted respectively on /sys/fs/cgroup/cpu and /sys/fs/cgroup/memory, the server will be started in the cgroups /sys/fs/cgroup/cpu/build/bazel and /sys/fs/cgroup/memory/build/bazel.It is not an error if the specified cgroup is not writable for one or more of the controllers. This options does not have any effect on platforms that do not support cgroups.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="startup_options-flag--experimental_run_in_user_cgroup"><code id="experimental_run_in_user_cgroup"><a href="#startup_options-flag--experimental_run_in_user_cgroup">--[no]experimental_run_in_user_cgroup</a></code> default: "false"</dt>
<dd>
<p>If true, the Bazel server will be run with systemd-run, and the user will own the cgroup. This flag only takes effect on Linux.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="startup_options-flag--failure_detail_out"><code id="failure_detail_out"><a href="#startup_options-flag--failure_detail_out">--failure_detail_out</a>=&lt;path&gt;</code> default: see description</dt>
<dd>
<p>If set, specifies a location to write a failure_detail protobuf message if the server experiences a failure and cannot report it via gRPC, as normal. Otherwise, the location will be ${OUTPUT_BASE}/failure_detail.rawproto.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="startup_options-flag--home_rc"><code id="home_rc"><a href="#startup_options-flag--home_rc">--[no]home_rc</a></code> default: "true"</dt>
<dd>
<p>Whether or not to look for the home bazelrc file at <code>$HOME/.bazelrc</code></p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="startup_options-flag--idle_server_tasks"><code id="idle_server_tasks"><a href="#startup_options-flag--idle_server_tasks">--[no]idle_server_tasks</a></code> default: "true"</dt>
<dd>
<p>Run System.gc() when the server is idle</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="startup_options-flag--ignore_all_rc_files"><code id="ignore_all_rc_files"><a href="#startup_options-flag--ignore_all_rc_files">--[no]ignore_all_rc_files</a></code> default: "false"</dt>
<dd>
<p>Disables all rc files, regardless of the values of other rc-modifying flags, even if these flags come later in the list of startup options.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="startup_options-flag--io_nice_level"><code id="io_nice_level"><a href="#startup_options-flag--io_nice_level">--io_nice_level</a>={-1,0,1,2,3,4,5,6,7}</code> default: "-1"</dt>
<dd>
<p>Only on Linux; set a level from 0-7 for best-effort IO scheduling using the sys_ioprio_set system call. 0 is highest priority, 7 is lowest. The anticipatory scheduler may only honor up to priority 4. If set to a negative value, then Bazel does not perform a system call.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="startup_options-flag--local_startup_timeout_secs"><code id="local_startup_timeout_secs"><a href="#startup_options-flag--local_startup_timeout_secs">--local_startup_timeout_secs</a>=&lt;an integer&gt;</code> default: "120"</dt>
<dd>
<p>The maximum amount of time the client waits to connect to the server</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="startup_options-flag--macos_qos_class"><code id="macos_qos_class"><a href="#startup_options-flag--macos_qos_class">--macos_qos_class</a>=&lt;a string&gt;</code> default: "default"</dt>
<dd>
<p>Sets the QoS service class of the bazel server when running on macOS. This flag has no effect on all other platforms but is supported to ensure rc files can be shared among them without changes. Possible values are: user-interactive, user-initiated, default, utility, and background.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="startup_options-flag--max_idle_secs"><code id="max_idle_secs"><a href="#startup_options-flag--max_idle_secs">--max_idle_secs</a>=&lt;integer&gt;</code> default: "10800"</dt>
<dd>
<p>The number of seconds the build server will wait idling before shutting down. Zero means that the server will never shutdown. This is only read on server-startup, changing this option will not cause the server to restart.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="startup_options-flag--output_base"><code id="output_base"><a href="#startup_options-flag--output_base">--output_base</a>=&lt;path&gt;</code> default: see description</dt>
<dd>
<p>If set, specifies the output location to which all build output will be written. Otherwise, the location will be ${OUTPUT_ROOT}/<em>blaze</em>${USER}/${MD5_OF_WORKSPACE_ROOT}. Note: If you specify a different option from one to the next Bazel invocation for this value, you'll likely start up a new, additional Bazel server. Bazel starts exactly one server per specified output base. Typically there is one output base per workspace - however, with this option you may have multiple output bases per workspace and thereby run multiple builds for the same client on the same machine concurrently. See 'bazel help shutdown' on how to shutdown a Bazel server.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="startup_options-flag--output_user_root"><code id="output_user_root"><a href="#startup_options-flag--output_user_root">--output_user_root</a>=&lt;path&gt;</code> default: see description</dt>
<dd>
<p>The user-specific directory beneath which all build outputs are written; by default, this is a function of $USER, but by specifying a constant, build outputs can be shared between collaborating users.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="startup_options-flag--preemptible"><code id="preemptible"><a href="#startup_options-flag--preemptible">--[no]preemptible</a></code> default: "false"</dt>
<dd>
<p>If true, the command can be preempted if another command is started.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="startup_options-flag--quiet"><code id="quiet"><a href="#startup_options-flag--quiet">--[no]quiet</a></code> default: "false"</dt>
<dd>
<p>If true, no informational messages are emitted on the console, only errors. Changing this option will not cause the server to restart.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="startup_options-flag--server_jvm_out"><code id="server_jvm_out"><a href="#startup_options-flag--server_jvm_out">--server_jvm_out</a>=&lt;path&gt;</code> default: see description</dt>
<dd>
<p>The location to write the server's JVM's output. If unset then defaults to a location in output_base.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="startup_options-flag--shutdown_on_low_sys_mem"><code id="shutdown_on_low_sys_mem"><a href="#startup_options-flag--shutdown_on_low_sys_mem">--[no]shutdown_on_low_sys_mem</a></code> default: "false"</dt>
<dd>
<p>If max_idle_secs is set and the build server has been idle for a while, shut down the server when the system is low on free RAM. Linux and MacOS only.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="startup_options-flag--system_rc"><code id="system_rc"><a href="#startup_options-flag--system_rc">--[no]system_rc</a></code> default: "true"</dt>
<dd>
<p>Whether or not to look for the system-wide bazelrc.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="startup_options-flag--unlimit_coredumps"><code id="unlimit_coredumps"><a href="#startup_options-flag--unlimit_coredumps">--[no]unlimit_coredumps</a></code> default: "false"</dt>
<dd>
<p>Raises the soft coredump limit to the hard limit to make coredumps of the server (including the JVM) and the client possible under common conditions. Stick this flag in your bazelrc once and forget about it so that you get coredumps when you actually encounter a condition that triggers them.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="startup_options-flag--windows_enable_symlinks"><code id="windows_enable_symlinks"><a href="#startup_options-flag--windows_enable_symlinks">--[no]windows_enable_symlinks</a></code> default: "false"</dt>
<dd>
<p>If true, real symbolic links will be created on Windows instead of file copying. Requires Windows developer mode to be enabled and Windows 10 version 1703 or greater.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="startup_options-flag--workspace_rc"><code id="workspace_rc"><a href="#startup_options-flag--workspace_rc">--[no]workspace_rc</a></code> default: "true"</dt>
<dd>
<p>Whether or not to look for the workspace bazelrc file at <code>$workspace/.bazelrc</code></p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
</dl>
<dl>Miscellaneous options, not otherwise categorized.:
<dt id="startup_options-flag--host_jvm_args"><code id="host_jvm_args"><a href="#startup_options-flag--host_jvm_args">--host_jvm_args</a>=&lt;jvm_arg&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Flags to pass to the JVM executing Blaze.</p>
</dd>
<dt id="startup_options-flag--host_jvm_debug"><code id="host_jvm_debug"><a href="#startup_options-flag--host_jvm_debug">--host_jvm_debug</a></code></dt>
<dd>
<p>Convenience option to add some additional JVM startup flags, which cause the JVM to wait during startup until you connect from a JDWP-compliant debugger (like Eclipse) to port 5005.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--host_jvm_args">--host_jvm_args=-agentlib:jdwp=transport=dt_socket,server=y,address=5005</a></code>
</p></dd>
<dt id="startup_options-flag--server_javabase"><code id="server_javabase"><a href="#startup_options-flag--server_javabase">--server_javabase</a>=&lt;jvm path&gt;</code> default: ""</dt>
<dd>
<p>Path to the JVM used to execute Bazel itself.</p>
</dd>
</dl>

<h2><a name="common_options">Options Common to all Commands</a></h2>
<dl>Options that appear before the command and are parsed by the client:
<dt id="common_options-flag--distdir"><code id="distdir"><a href="#common_options-flag--distdir">--distdir</a>=&lt;a path&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional places to search for archives before accessing the network to download them.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="common_options-flag--experimental_repository_cache_hardlinks"><code id="experimental_repository_cache_hardlinks"><a href="#common_options-flag--experimental_repository_cache_hardlinks">--[no]experimental_repository_cache_hardlinks</a></code> default: "false"</dt>
<dd>
<p>If set, the repository cache will hardlink the file in case of a cache hit, rather than copying. This is intended to save disk space.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="common_options-flag--experimental_repository_downloader_retries"><code id="experimental_repository_downloader_retries"><a href="#common_options-flag--experimental_repository_downloader_retries">--experimental_repository_downloader_retries</a>=&lt;an integer&gt;</code> default: "5"</dt>
<dd>
<p>The maximum number of attempts to retry a download error. If set to 0, retries are disabled.</p>
<p>Tags:
<a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--experimental_scale_timeouts"><code id="experimental_scale_timeouts"><a href="#common_options-flag--experimental_scale_timeouts">--experimental_scale_timeouts</a>=&lt;a double&gt;</code> default: "1.0"</dt>
<dd>
<p>Scale all timeouts in Starlark repository rules by this factor. In this way, external repositories can be made working on machines that are slower than the rule author expected, without changing the source code</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--http_connector_attempts"><code id="http_connector_attempts"><a href="#common_options-flag--http_connector_attempts">--http_connector_attempts</a>=&lt;an integer&gt;</code> default: "8"</dt>
<dd>
<p>The maximum number of attempts for http downloads.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="common_options-flag--http_connector_retry_max_timeout"><code id="http_connector_retry_max_timeout"><a href="#common_options-flag--http_connector_retry_max_timeout">--http_connector_retry_max_timeout</a>=&lt;An immutable length of time.&gt;</code> default: "0s"</dt>
<dd>
<p>The maximum timeout for http download retries. With a value of 0, no timeout maximum is defined.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="common_options-flag--http_max_parallel_downloads"><code id="http_max_parallel_downloads"><a href="#common_options-flag--http_max_parallel_downloads">--http_max_parallel_downloads</a>=&lt;an integer&gt;</code> default: "8"</dt>
<dd>
<p>The maximum number parallel http downloads.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="common_options-flag--http_timeout_scaling"><code id="http_timeout_scaling"><a href="#common_options-flag--http_timeout_scaling">--http_timeout_scaling</a>=&lt;a double&gt;</code> default: "1.0"</dt>
<dd>
<p>Scale all timeouts related to http downloads by the given factor</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="common_options-flag--repo_contents_cache"><code id="repo_contents_cache"><a href="#common_options-flag--repo_contents_cache">--repo_contents_cache</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>Specifies the location of the repo contents cache, which contains fetched repo
directories shareable across workspaces. An empty string as argument requests the repo
contents cache to be disabled, otherwise the default of <code>{--repository_cache}/contents</code>
is used. Note that this means setting <code>--repository_cache=</code> would by default disable the
repo contents cache as well, unless <code>--repo_contents_cache={some_path}</code> is also set.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="common_options-flag--repo_contents_cache_gc_idle_delay"><code id="repo_contents_cache_gc_idle_delay"><a href="#common_options-flag--repo_contents_cache_gc_idle_delay">--repo_contents_cache_gc_idle_delay</a>=&lt;An immutable length of time.&gt;</code> default: "5m"</dt>
<dd>
<p>Specifies the amount of time the server must remain idle before garbage collection happens
to the repo contents cache.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="common_options-flag--repo_contents_cache_gc_max_age"><code id="repo_contents_cache_gc_max_age"><a href="#common_options-flag--repo_contents_cache_gc_max_age">--repo_contents_cache_gc_max_age</a>=&lt;An immutable length of time.&gt;</code> default: "14d"</dt>
<dd>
<p>Specifies the amount of time an entry in the repo contents cache can stay unused before
it's garbage collected. If set to zero, only duplicate entries will be garbage collected.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="common_options-flag--repository_cache"><code id="repository_cache"><a href="#common_options-flag--repository_cache">--repository_cache</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>Specifies the cache location of the downloaded values obtained
during the fetching of external repositories. An empty string
as argument requests the cache to be disabled,
otherwise the default of <code>{--output_user_root}/cache/repos/v1</code> is used.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="common_options-flag--repository_disable_download"><code id="repository_disable_download"><a href="#common_options-flag--repository_disable_download">--[no]repository_disable_download</a></code> default: "false"</dt>
<dd>
<p>If set, downloading using <code>ctx.download{,_and_extract}</code> is not allowed during repository
fetching. Note that network access is not completely disabled; ctx.execute could
still run an arbitrary executable that accesses the Internet.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
</dl>
<dl>Options that control build execution:
<dt id="common_options-flag--experimental_ui_max_stdouterr_bytes"><code id="experimental_ui_max_stdouterr_bytes"><a href="#common_options-flag--experimental_ui_max_stdouterr_bytes">--experimental_ui_max_stdouterr_bytes</a>=&lt;an integer in (-1)-1073741819 range&gt;</code> default: "1048576"</dt>
<dd>
<p>The maximum size of the stdout / stderr files that will be printed to the console. -1 implies no limit.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="common_options-flag--gc_churning_threshold"><code id="gc_churning_threshold"><a href="#common_options-flag--gc_churning_threshold">--gc_churning_threshold</a>=&lt;an integer in 0-100 range&gt;</code> default: "100"</dt>
<dd>
<p>At any point after an invocation has been running for at least one minute, if Blaze has spent at least this percentage of the invocation's wall time doing full GCs, Blaze will give up and fail with an OOM. A value of 100 effectively means to never give up for this reason.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="common_options-flag--gc_churning_threshold_if_multiple_top_level_targets"><code id="gc_churning_threshold_if_multiple_top_level_targets"><a href="#common_options-flag--gc_churning_threshold_if_multiple_top_level_targets">--gc_churning_threshold_if_multiple_top_level_targets</a>=&lt;an integer&gt;</code> default: "-1"</dt>
<dd>
<p>If set to a value in [0, 100] and this is a command that takes top-level targets (e.g. build but not query) and there are multiple such top-level targets, overrides --gc_churning_threshold. Useful to configure more aggressive OOMing behavior (i.e. a lower value than --gc_churning_threshold) when they are multiple top-level targets so that the invoker of Bazel can split and retry while still having less aggressive behavior when there is a single top-level target.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="common_options-flag--gc_thrashing_threshold"><code id="gc_thrashing_threshold"><a href="#common_options-flag--gc_thrashing_threshold">--gc_thrashing_threshold</a>=&lt;an integer in 0-100 range&gt;</code> default: "100"</dt>
<dd>
<p>The percent of tenured space occupied (0-100) above which GcThrashingDetector considers memory pressure events against its limits (--gc_thrashing_limits). If set to 100, GcThrashingDetector is disabled.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
</dl>
<dl>Options that configure the toolchain used for action execution:
<dt id="common_options-flag--incompatible_enable_proto_toolchain_resolution"><code id="incompatible_enable_proto_toolchain_resolution"><a href="#common_options-flag--incompatible_enable_proto_toolchain_resolution">--[no]incompatible_enable_proto_toolchain_resolution</a></code> default: "false"</dt>
<dd>
<p>If true, proto lang rules define toolchains from protobuf repository.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options that let the user configure the intended output, affecting its value, as opposed to its existence:
<dt id="common_options-flag--bep_maximum_open_remote_upload_files"><code id="bep_maximum_open_remote_upload_files"><a href="#common_options-flag--bep_maximum_open_remote_upload_files">--bep_maximum_open_remote_upload_files</a>=&lt;an integer&gt;</code> default: "-1"</dt>
<dd>
<p>Maximum number of open files allowed during BEP artifact upload.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--remote_download_all"><code id="remote_download_all"><a href="#common_options-flag--remote_download_all">--remote_download_all</a></code></dt>
<dd>
<p>Downloads all remote outputs to the local machine. This flag is an alias for --remote_download_outputs=all.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--remote_download_outputs">--remote_download_outputs=all</a></code>
</p><p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--remote_download_minimal"><code id="remote_download_minimal"><a href="#common_options-flag--remote_download_minimal">--remote_download_minimal</a></code></dt>
<dd>
<p>Does not download any remote build outputs to the local machine. This flag is an alias for --remote_download_outputs=minimal.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--remote_download_outputs">--remote_download_outputs=minimal</a></code>
</p><p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--remote_download_outputs"><code id="remote_download_outputs"><a href="#common_options-flag--remote_download_outputs">--remote_download_outputs</a>=&lt;all, minimal or toplevel&gt;</code> default: "toplevel"</dt>
<dd>
<p>If set to 'minimal' doesn't download any remote build outputs to the local machine, except the ones required by local actions. If set to 'toplevel' behaves like 'minimal' except that it also downloads outputs of top level targets to the local machine. Both options can significantly reduce build times if network bandwidth is a bottleneck.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--remote_download_symlink_template"><code id="remote_download_symlink_template"><a href="#common_options-flag--remote_download_symlink_template">--remote_download_symlink_template</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Instead of downloading remote build outputs to the local machine, create symbolic links. The target of the symbolic links can be specified in the form of a template string. This template string may contain {hash} and {size_bytes} that expand to the hash of the object and the size in bytes, respectively. These symbolic links may, for example, point to a FUSE file system that loads objects from the CAS on demand.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--remote_download_toplevel"><code id="remote_download_toplevel"><a href="#common_options-flag--remote_download_toplevel">--remote_download_toplevel</a></code></dt>
<dd>
<p>Only downloads remote outputs of top level targets to the local machine. This flag is an alias for --remote_download_outputs=toplevel.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--remote_download_outputs">--remote_download_outputs=toplevel</a></code>
</p><p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--repo_env"><code id="repo_env"><a href="#common_options-flag--repo_env">--repo_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies additional environment variables to be available only for repository rules. Note that repository rules see the full environment anyway, but in this way variables can be set via command-line flags and &lt;code&gt;.bazelrc&lt;/code&gt; entries. The special syntax &lt;code&gt;=NAME&lt;/code&gt; can be used to explicitly unset a variable.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
</dl>
<dl>Options that affect how strictly Bazel enforces valid build inputs (rule definitions,  flag combinations, etc.):
<dt id="common_options-flag--allow_experimental_loads"><code id="allow_experimental_loads"><a href="#common_options-flag--allow_experimental_loads">--[no]allow_experimental_loads</a></code> default: "false"</dt>
<dd>
<p>If enabled, issue only a warning instead of an error for loads of experimental .bzls.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="common_options-flag--check_bzl_visibility"><code id="check_bzl_visibility"><a href="#common_options-flag--check_bzl_visibility">--[no]check_bzl_visibility</a></code> default: "true"</dt>
<dd>
<p>If disabled, .bzl load visibility errors are demoted to warnings.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_enforce_starlark_utf8"><code id="incompatible_enforce_starlark_utf8"><a href="#common_options-flag--incompatible_enforce_starlark_utf8">--[no]incompatible_enforce_starlark_utf8</a></code> default: "warning"</dt>
<dd>
<p>If enabled (or set to 'error'), fail if Starlark files are not UTF-8 encoded. If set to 'warning', emit a warning instead. If set to 'off', Bazel assumes that Starlark files are UTF-8 encoded but does not verify this assumption. Note that Starlark files which are not UTF-8 encoded can cause Bazel to behave inconsistently.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>This option affects semantics of the Starlark language or the build API accessible to BUILD files, .bzl files, or WORKSPACE files.:
<dt id="common_options-flag--experimental_bzl_visibility"><code id="experimental_bzl_visibility"><a href="#common_options-flag--experimental_bzl_visibility">--[no]experimental_bzl_visibility</a></code> default: "true"</dt>
<dd>
<p>If enabled, adds a <code>visibility()</code> function that .bzl files may call during top-level evaluation to set their visibility for the purpose of load() statements.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--experimental_cc_shared_library"><code id="experimental_cc_shared_library"><a href="#common_options-flag--experimental_cc_shared_library">--[no]experimental_cc_shared_library</a></code> default: "false"</dt>
<dd>
<p>If set to true, rule attributes and Starlark API methods needed for the rule cc_shared_library will be available</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--experimental_disable_external_package"><code id="experimental_disable_external_package"><a href="#common_options-flag--experimental_disable_external_package">--[no]experimental_disable_external_package</a></code> default: "false"</dt>
<dd>
<p>If set to true, the auto-generated //external package will not be available anymore. Bazel will still be unable to parse the file 'external/BUILD', but globs reaching into external/ from the unnamed package will work.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--experimental_dormant_deps"><code id="experimental_dormant_deps"><a href="#common_options-flag--experimental_dormant_deps">--[no]experimental_dormant_deps</a></code> default: "false"</dt>
<dd>
<p>If set to true, attr.label(materializer=), attr(for_dependency_resolution=), attr.dormant_label(), attr.dormant_label_list() and rule(for_dependency_resolution=) are allowed.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--experimental_enable_android_migration_apis"><code id="experimental_enable_android_migration_apis"><a href="#common_options-flag--experimental_enable_android_migration_apis">--[no]experimental_enable_android_migration_apis</a></code> default: "false"</dt>
<dd>
<p>If set to true, enables the APIs required to support the Android Starlark migration.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="common_options-flag--experimental_enable_first_class_macros"><code id="experimental_enable_first_class_macros"><a href="#common_options-flag--experimental_enable_first_class_macros">--[no]experimental_enable_first_class_macros</a></code> default: "true"</dt>
<dd>
<p>If set to true, enables the <code>macro()</code> construct for defining symbolic macros.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="common_options-flag--experimental_enable_scl_dialect"><code id="experimental_enable_scl_dialect"><a href="#common_options-flag--experimental_enable_scl_dialect">--[no]experimental_enable_scl_dialect</a></code> default: "true"</dt>
<dd>
<p>If set to true, .scl files may be used in load() statements.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="common_options-flag--experimental_enable_starlark_set"><code id="experimental_enable_starlark_set"><a href="#common_options-flag--experimental_enable_starlark_set">--[no]experimental_enable_starlark_set</a></code> default: "true"</dt>
<dd>
<p>If true, enable the set data type and set() constructor in Starlark.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--experimental_google_legacy_api"><code id="experimental_google_legacy_api"><a href="#common_options-flag--experimental_google_legacy_api">--[no]experimental_google_legacy_api</a></code> default: "false"</dt>
<dd>
<p>If set to true, exposes a number of experimental pieces of Starlark build API pertaining to Google legacy code.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--experimental_isolated_extension_usages"><code id="experimental_isolated_extension_usages"><a href="#common_options-flag--experimental_isolated_extension_usages">--[no]experimental_isolated_extension_usages</a></code> default: "false"</dt>
<dd>
<p>If true, enables the &lt;code&gt;isolate&lt;/code&gt; parameter in the &lt;a href=&quot;https://bazel.build/rules/lib/globals/module#use_extension&quot;&gt;&lt;code&gt;use_extension&lt;/code&gt;&lt;/a&gt; function.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="common_options-flag--experimental_platforms_api"><code id="experimental_platforms_api"><a href="#common_options-flag--experimental_platforms_api">--[no]experimental_platforms_api</a></code> default: "false"</dt>
<dd>
<p>If set to true, enables a number of platform-related Starlark APIs useful for debugging.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--experimental_repo_remote_exec"><code id="experimental_repo_remote_exec"><a href="#common_options-flag--experimental_repo_remote_exec">--[no]experimental_repo_remote_exec</a></code> default: "false"</dt>
<dd>
<p>If set to true, repository_rule gains some remote execution capabilities.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--experimental_repository_ctx_execute_wasm"><code id="experimental_repository_ctx_execute_wasm"><a href="#common_options-flag--experimental_repository_ctx_execute_wasm">--[no]experimental_repository_ctx_execute_wasm</a></code> default: "false"</dt>
<dd>
<p>If true enables the repository_ctx <code>load_wasm</code> and <code>execute_wasm</code> methods.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--experimental_sibling_repository_layout"><code id="experimental_sibling_repository_layout"><a href="#common_options-flag--experimental_sibling_repository_layout">--[no]experimental_sibling_repository_layout</a></code> default: "false"</dt>
<dd>
<p>If set to true, non-main repositories are planted as symlinks to the main repository in the execution root. That is, all repositories are direct children of the $output_base/execution_root directory. This has the side effect of freeing up $output_base/execution_root/<strong>main</strong>/external for the real top-level 'external' directory.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--experimental_single_package_toolchain_binding"><code id="experimental_single_package_toolchain_binding"><a href="#common_options-flag--experimental_single_package_toolchain_binding">--[no]experimental_single_package_toolchain_binding</a></code> default: "false"</dt>
<dd>
<p>If enabled, the register_toolchain function may not include target patterns which may refer to more than one package.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--experimental_starlark_type_checking"><code id="experimental_starlark_type_checking"><a href="#common_options-flag--experimental_starlark_type_checking">--[no]experimental_starlark_type_checking</a></code> default: "false"</dt>
<dd>
<p>Enables type checking in files and functions that contain type annotations or related syntax.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--experimental_starlark_type_syntax"><code id="experimental_starlark_type_syntax"><a href="#common_options-flag--experimental_starlark_type_syntax">--[no]experimental_starlark_type_syntax</a></code> default: "true"</dt>
<dd>
<p>Enables type annotations and related syntax. Locations of files where these are allowed is further restricted by <code>--experimental_starlark_types_allowed_paths</code>.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--experimental_starlark_types_allowed_paths"><code id="experimental_starlark_types_allowed_paths"><a href="#common_options-flag--experimental_starlark_types_allowed_paths">--experimental_starlark_types_allowed_paths</a>=&lt;comma-separated list of options&gt;</code> default: ""</dt>
<dd>
<p>List of canonical Label prefixes under which Starlark type annotations are allowed.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_allow_tags_propagation"><code id="incompatible_allow_tags_propagation"><a href="#common_options-flag--incompatible_allow_tags_propagation">--[no]incompatible_allow_tags_propagation</a></code> default: "true"</dt>
<dd>
<p>If set to true, tags will be propagated from a target to the actions' execution requirements; otherwise tags are not propagated. See https://github.com/bazelbuild/bazel/issues/8830 for details.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_always_check_depset_elements"><code id="incompatible_always_check_depset_elements"><a href="#common_options-flag--incompatible_always_check_depset_elements">--[no]incompatible_always_check_depset_elements</a></code> default: "true"</dt>
<dd>
<p>Check the validity of elements added to depsets, in all constructors. Elements must be immutable, but historically the depset(direct=...) constructor forgot to check. Use tuples instead of lists in depset elements. See https://github.com/bazelbuild/bazel/issues/10313 for details.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_autoload_externally"><code id="incompatible_autoload_externally"><a href="#common_options-flag--incompatible_autoload_externally">--incompatible_autoload_externally</a>=&lt;comma-separated set of options&gt;</code> default: "+@rules_cc"</dt>
<dd>
<p>A comma-separated list of rules (or other symbols) that were previously part of Bazel and which are now to be retrieved from their respective external repositories. This flag is intended to be used to facilitate migration of rules out of Bazel. See also https://github.com/bazelbuild/bazel/issues/23043.
A symbol that is autoloaded within a file behaves as if its built-into-Bazel definition were replaced by its canonical new definition in an external repository. For a BUILD file, this essentially means implicitly adding a load() statement. For a .bzl file, it's either a load() statement or a change to a field of the <code>native</code> object, depending on whether the autoloaded symbol is a rule.
Bazel maintains a hardcoded list of all symbols that may be autoloaded; only those symbols may appear in this flag. For each symbol, Bazel knows the new definition location in an external repository, as well as a set of special-cased repositories that must not autoload it to avoid creating cycles.
A list item of &quot;+foo&quot; in this flag causes symbol foo to be autoloaded, except in foo's exempt repositories, within which the Bazel-defined version of foo is still available.
A list item of &quot;foo&quot; triggers autoloading as above, but the Bazel-defined version of foo is not made available to the excluded repositories. This ensures that foo's external repository does not depend on the old Bazel implementation of foo
A list item of &quot;-foo&quot; does not trigger any autoloading, but makes the Bazel-defined version of foo inaccessible throughout the workspace. This is used to validate that the workspace is ready for foo's definition to be deleted from Bazel.
If a symbol is not named in this flag then it continues to work as normal -- no autoloading is done, nor is the Bazel-defined version suppressed. For configuration see https://github.com/bazelbuild/bazel/blob/master/src/main/java/com/google/devtools/build/lib/packages/AutoloadSymbols.java As a shortcut also whole repository may be used, for example +@rules_python will autoload all Python rules.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_disable_autoloads_in_main_repo"><code id="incompatible_disable_autoloads_in_main_repo"><a href="#common_options-flag--incompatible_disable_autoloads_in_main_repo">--[no]incompatible_disable_autoloads_in_main_repo</a></code> default: "true"</dt>
<dd>
<p>Controls if the autoloads (set by --incompatible_autoload_externally) are enabled in themain repository. When enabled the rules (or other symbols) that were previously part of Bazel need to have load statements. Use buildifier to add them.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_disable_objc_library_transition"><code id="incompatible_disable_objc_library_transition"><a href="#common_options-flag--incompatible_disable_objc_library_transition">--[no]incompatible_disable_objc_library_transition</a></code> default: "true"</dt>
<dd>
<p>Disable objc_library's custom transition and inherit from the top level target instead (No-op in Bazel)</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_disable_starlark_host_transitions"><code id="incompatible_disable_starlark_host_transitions"><a href="#common_options-flag--incompatible_disable_starlark_host_transitions">--[no]incompatible_disable_starlark_host_transitions</a></code> default: "false"</dt>
<dd>
<p>If set to true, rule attributes cannot set 'cfg = &quot;host&quot;'. Rules should set 'cfg = &quot;exec&quot;' instead.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_disable_target_default_provider_fields"><code id="incompatible_disable_target_default_provider_fields"><a href="#common_options-flag--incompatible_disable_target_default_provider_fields">--[no]incompatible_disable_target_default_provider_fields</a></code> default: "false"</dt>
<dd>
<p>If set to true, disable the ability to utilize the default provider via field syntax. Use provider-key syntax instead. For example, instead of using <code>ctx.attr.dep.files</code> to access <code>files</code>, utilize `ctx.attr.dep[DefaultInfo].files See https://github.com/bazelbuild/bazel/issues/9014 for details.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_disable_transitions_on"><code id="incompatible_disable_transitions_on"><a href="#common_options-flag--incompatible_disable_transitions_on">--incompatible_disable_transitions_on</a>=&lt;comma-separated set of options&gt;</code> default: ""</dt>
<dd>
<p>A comma-separated list of flags that cannot be used in transitions inputs or outputs.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_disallow_ctx_resolve_tools"><code id="incompatible_disallow_ctx_resolve_tools"><a href="#common_options-flag--incompatible_disallow_ctx_resolve_tools">--[no]incompatible_disallow_ctx_resolve_tools</a></code> default: "true"</dt>
<dd>
<p>If set to true, calling the deprecated ctx.resolve_tools API always fails. Uses of this API should be replaced by an executable or tools argument to ctx.actions.run or ctx.actions.run_shell.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_disallow_empty_glob"><code id="incompatible_disallow_empty_glob"><a href="#common_options-flag--incompatible_disallow_empty_glob">--[no]incompatible_disallow_empty_glob</a></code> default: "true"</dt>
<dd>
<p>If set to true, the default value of the <code>allow_empty</code> argument of glob() is False.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_enable_deprecated_label_apis"><code id="incompatible_enable_deprecated_label_apis"><a href="#common_options-flag--incompatible_enable_deprecated_label_apis">--[no]incompatible_enable_deprecated_label_apis</a></code> default: "true"</dt>
<dd>
<p>If enabled, certain deprecated APIs (native.repository_name, Label.workspace_name, Label.relative) can be used.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_fail_on_unknown_attributes"><code id="incompatible_fail_on_unknown_attributes"><a href="#common_options-flag--incompatible_fail_on_unknown_attributes">--[no]incompatible_fail_on_unknown_attributes</a></code> default: "true"</dt>
<dd>
<p>If enabled, targets that have unknown attributes set to None fail.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_fix_package_group_reporoot_syntax"><code id="incompatible_fix_package_group_reporoot_syntax"><a href="#common_options-flag--incompatible_fix_package_group_reporoot_syntax">--[no]incompatible_fix_package_group_reporoot_syntax</a></code> default: "true"</dt>
<dd>
<p>In package_group's <code>packages</code> attribute, changes the meaning of the value &quot;//...&quot; to refer to all packages in the current repository instead of all packages in any repository. You can use the special value &quot;public&quot; in place of &quot;//...&quot; to obtain the old behavior. This flag requires that --incompatible_package_group_has_public_syntax also be enabled.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_locations_prefers_executable"><code id="incompatible_locations_prefers_executable"><a href="#common_options-flag--incompatible_locations_prefers_executable">--[no]incompatible_locations_prefers_executable</a></code> default: "true"</dt>
<dd>
<p>Whether a target that provides an executable expands to the executable rather than the files in &lt;code&gt;DefaultInfo.files&lt;/code&gt; under $(locations ...) expansion if the number of files is not 1.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_no_attr_license"><code id="incompatible_no_attr_license"><a href="#common_options-flag--incompatible_no_attr_license">--[no]incompatible_no_attr_license</a></code> default: "true"</dt>
<dd>
<p>If set to true, disables the function <code>attr.license</code>.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_no_implicit_file_export"><code id="incompatible_no_implicit_file_export"><a href="#common_options-flag--incompatible_no_implicit_file_export">--[no]incompatible_no_implicit_file_export</a></code> default: "false"</dt>
<dd>
<p>If set, (used) source files are package private unless exported explicitly. See https://github.com/bazelbuild/proposals/blob/master/designs/2019-10-24-file-visibility.md</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_no_implicit_watch_label"><code id="incompatible_no_implicit_watch_label"><a href="#common_options-flag--incompatible_no_implicit_watch_label">--[no]incompatible_no_implicit_watch_label</a></code> default: "true"</dt>
<dd>
<p>If true, then methods on &lt;code&gt;repository_ctx&lt;/code&gt; that are passed a Label will no longer automatically watch the file under that label for changes even if &lt;code&gt;watch = &quot;no&quot;&lt;/code&gt;, and &lt;code&gt;repository_ctx.path&lt;/code&gt; no longer causes the returned path to be watched. Use &lt;code&gt;repository_ctx.watch&lt;/code&gt; instead.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_no_rule_outputs_param"><code id="incompatible_no_rule_outputs_param"><a href="#common_options-flag--incompatible_no_rule_outputs_param">--[no]incompatible_no_rule_outputs_param</a></code> default: "false"</dt>
<dd>
<p>If set to true, disables the <code>outputs</code> parameter of the <code>rule()</code> Starlark function.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_package_group_has_public_syntax"><code id="incompatible_package_group_has_public_syntax"><a href="#common_options-flag--incompatible_package_group_has_public_syntax">--[no]incompatible_package_group_has_public_syntax</a></code> default: "true"</dt>
<dd>
<p>In package_group's <code>packages</code> attribute, allows writing &quot;public&quot; or &quot;private&quot; to refer to all packages or no packages respectively.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_resolve_select_keys_eagerly"><code id="incompatible_resolve_select_keys_eagerly"><a href="#common_options-flag--incompatible_resolve_select_keys_eagerly">--[no]incompatible_resolve_select_keys_eagerly</a></code> default: "false"</dt>
<dd>
<p>If enabled, string keys in dicts passed to select() in .bzl files are immediately resolved to Labels relative to the file instead of being interpreted relative to the BUILD file they are ultimately loaded from.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_run_shell_command_string"><code id="incompatible_run_shell_command_string"><a href="#common_options-flag--incompatible_run_shell_command_string">--[no]incompatible_run_shell_command_string</a></code> default: "true"</dt>
<dd>
<p>If set to true, the command parameter of actions.run_shell will only accept string</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_simplify_unconditional_selects_in_rule_attrs"><code id="incompatible_simplify_unconditional_selects_in_rule_attrs"><a href="#common_options-flag--incompatible_simplify_unconditional_selects_in_rule_attrs">--[no]incompatible_simplify_unconditional_selects_in_rule_attrs</a></code> default: "true"</dt>
<dd>
<p>If true, simplify configurable rule attributes which contain only unconditional selects; for example, if [&quot;a&quot;] + select(&quot;//conditions:default&quot;, [&quot;b&quot;]) is assigned to a rule attribute, it is stored as [&quot;a&quot;, &quot;b&quot;]. This option does not affect attributes of symbolic macros or attribute default values.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_stop_exporting_build_file_path"><code id="incompatible_stop_exporting_build_file_path"><a href="#common_options-flag--incompatible_stop_exporting_build_file_path">--[no]incompatible_stop_exporting_build_file_path</a></code> default: "false"</dt>
<dd>
<p>If set to true, deprecated ctx.build_file_path will not be available. ctx.label.package + '/BUILD' can be used instead.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_stop_exporting_language_modules"><code id="incompatible_stop_exporting_language_modules"><a href="#common_options-flag--incompatible_stop_exporting_language_modules">--[no]incompatible_stop_exporting_language_modules</a></code> default: "false"</dt>
<dd>
<p>If enabled, certain language-specific modules (such as <code>cc_common</code>) are unavailable in user .bzl files and may only be called from their respective rules repositories.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_unambiguous_label_stringification"><code id="incompatible_unambiguous_label_stringification"><a href="#common_options-flag--incompatible_unambiguous_label_stringification">--[no]incompatible_unambiguous_label_stringification</a></code> default: "true"</dt>
<dd>
<p>When true, Bazel will stringify the label @//foo:bar to @//foo:bar, instead of //foo:bar. This only affects the behavior of str(), the % operator, and so on; the behavior of repr() is unchanged. See https://github.com/bazelbuild/bazel/issues/15916 for more information.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_use_cc_configure_from_rules_cc"><code id="incompatible_use_cc_configure_from_rules_cc"><a href="#common_options-flag--incompatible_use_cc_configure_from_rules_cc">--[no]incompatible_use_cc_configure_from_rules_cc</a></code> default: "false"</dt>
<dd>
<p>When true, Bazel will no longer allow using cc_configure from @bazel_tools. Please see https://github.com/bazelbuild/bazel/issues/10134 for details and migration instructions.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--max_computation_steps"><code id="max_computation_steps"><a href="#common_options-flag--max_computation_steps">--max_computation_steps</a>=&lt;a long integer&gt;</code> default: "0"</dt>
<dd>
<p>The maximum number of Starlark computation steps that may be executed by a BUILD file (zero means no limit).</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="common_options-flag--nested_set_depth_limit"><code id="nested_set_depth_limit"><a href="#common_options-flag--nested_set_depth_limit">--nested_set_depth_limit</a>=&lt;an integer&gt;</code> default: "3500"</dt>
<dd>
<p>The maximum depth of the graph internal to a depset (also known as NestedSet), above which the depset() constructor will fail.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="common_options-flag--repositories_without_autoloads"><code id="repositories_without_autoloads"><a href="#common_options-flag--repositories_without_autoloads">--repositories_without_autoloads</a>=&lt;comma-separated set of options&gt;</code> default: ""</dt>
<dd>
<p>A list of additional repositories (beyond the hardcoded ones Bazel knows about) where autoloads are not to be added. This should typically contain repositories that are transitively depended on by a repository that may be loaded automatically (and which can therefore potentially create a cycle).</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options relating to Bzlmod output and semantics:
<dt id="common_options-flag--allow_yanked_versions"><code id="allow_yanked_versions"><a href="#common_options-flag--allow_yanked_versions">--allow_yanked_versions</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specified the module versions in the form of
<code>{module1}@{version1},module2@{version2}</code> that will be allowed in the resolved
dependency graph even if they are declared yanked in the registry where they come
from (if they are not coming from a <a href="https://github.com/bazelbuild/bazel/blob/master/src/main/java/com/google/devtools/build/lib/bazel/bzlmod/NonRegistryOverride.java"><code>NonRegistryOverride</code></a>).
Otherwise, yanked versions will cause the resolution to fail. You can also define allowed
yanked versions with the <code>BZLMOD_ALLOW_YANKED_VERSIONS</code> environment variable. You can
disable this check by using the keyword <code>all</code> (not recommended).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="common_options-flag--check_bazel_compatibility"><code id="check_bazel_compatibility"><a href="#common_options-flag--check_bazel_compatibility">--check_bazel_compatibility</a>=&lt;error, warning or off&gt;</code> default: "error"</dt>
<dd>
<p>Check bazel version compatibility of Bazel modules. Valid values are <code>error</code> to escalate it to a resolution failure, <code>off</code> to disable the check, or <code>warning</code> to print a warning when mismatch detected.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="common_options-flag--check_direct_dependencies"><code id="check_direct_dependencies"><a href="#common_options-flag--check_direct_dependencies">--check_direct_dependencies</a>=&lt;off, warning or error&gt;</code> default: "warning"</dt>
<dd>
<p>Check if the direct <code>bazel_dep</code> dependencies declared in the root module are the same versions you get in the resolved dependency graph. Valid values are <code>off</code> to disable the check, <code>warning</code> to print a warning when mismatch detected or <code>error</code> to escalate it to a resolution failure.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="common_options-flag--ignore_dev_dependency"><code id="ignore_dev_dependency"><a href="#common_options-flag--ignore_dev_dependency">--[no]ignore_dev_dependency</a></code> default: "false"</dt>
<dd>
<p>If true, Bazel ignores <code>bazel_dep</code> and <code>use_extension</code> declared as <code>dev_dependency</code> in
the <code>MODULE.bazel</code> of the root module. Note that, those dev dependencies are always
ignored in the <code>MODULE.bazel</code> if it's not the root module regardless of the value
of this flag.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="common_options-flag--lockfile_mode"><code id="lockfile_mode"><a href="#common_options-flag--lockfile_mode">--lockfile_mode</a>=&lt;off, update, refresh or error&gt;</code> default: "update"</dt>
<dd>
<p>Specifies how and whether or not to use the lockfile. Valid values are <code>update</code> to use the lockfile and update it if there are changes, <code>refresh</code> to additionally refresh mutable information (yanked versions and previously missing modules) from remote registries from time to time, <code>error</code> to use the lockfile but throw an error if it's not up-to-date, or <code>off</code> to neither read from or write to the lockfile.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="common_options-flag--module_mirrors"><code id="module_mirrors"><a href="#common_options-flag--module_mirrors">--module_mirrors</a>=&lt;comma-separated list of options&gt;</code> default: see description</dt>
<dd>
<p>A comma-separated list of URLs under which the source URLs of Bazel modules can be found,
in addition to and taking precedence over any registry-provided mirror URLs. Set this to
an empty value to disable the use of any mirrors not specified by the registries. The
default set of mirrors may change over time, but all downloads from mirrors are verified
by hashes stored in the registry (and thus pinned by the lockfile).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="common_options-flag--override_module"><code id="override_module"><a href="#common_options-flag--override_module">--override_module</a>=&lt;an equals-separated mapping of module name to path&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Override a module with a local path in the form of <code>{module name}={path}</code>. If the given
path is an absolute path, it will be used as it is. If the given path is a
relative path, it is relative to the current working directory. If the given path
starts with <code>%workspace%</code>, it is relative to the workspace root, which is the
output of <code>bazel info workspace</code>. If the given path is empty, then remove any
previous overrides.</p>
</dd>
<dt id="common_options-flag--registry"><code id="registry"><a href="#common_options-flag--registry">--registry</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the registries to use to locate Bazel module dependencies. The order is important: modules will be looked up in earlier registries first, and only fall back to later registries when they're missing from the earlier ones.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="common_options-flag--vendor_dir"><code id="vendor_dir"><a href="#common_options-flag--vendor_dir">--vendor_dir</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>Specifies the directory that should hold the external repositories in vendor mode, whether for the purpose of fetching them into it or using them while building. The path can be specified as either an absolute path or a path relative to the workspace directory.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
</dl>
<dl>Options that trigger optimizations of the build time:
<dt id="common_options-flag--gc_thrashing_limits"><code id="gc_thrashing_limits"><a href="#common_options-flag--gc_thrashing_limits">--gc_thrashing_limits</a>=&lt;comma separated pairs of &lt;period&gt;:&lt;count&gt;&gt;</code> default: "1s:2,20s:3,1m:5"</dt>
<dd>
<p>Limits which, if reached, cause GcThrashingDetector to crash Bazel with an OOM. Each limit is specified as &lt;period&gt;:&lt;count&gt; where period is a duration and count is a positive integer. If more than --gc_thrashing_threshold percent of tenured space (old gen heap) remains occupied after &lt;count&gt; consecutive full GCs within &lt;period&gt;, an OOM is triggered. Multiple limits can be specified separated by commas.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="common_options-flag--heuristically_drop_nodes"><code id="heuristically_drop_nodes"><a href="#common_options-flag--heuristically_drop_nodes">--[no]heuristically_drop_nodes</a></code> default: "false"</dt>
<dd>
<p>If true, Blaze will remove FileState and DirectoryListingState nodes after related File and DirectoryListing node is done to save memory. We expect that it is less likely that these nodes will be needed again. If so, the program will re-evaluate them.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_do_not_split_linking_cmdline"><code id="incompatible_do_not_split_linking_cmdline"><a href="#common_options-flag--incompatible_do_not_split_linking_cmdline">--[no]incompatible_do_not_split_linking_cmdline</a></code> default: "true"</dt>
<dd>
<p>When true, Bazel no longer modifies command line flags used for linking, and also doesn't selectively decide which flags go to the param file and which don't.  See https://github.com/bazelbuild/bazel/issues/7670 for details.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--keep_state_after_build"><code id="keep_state_after_build"><a href="#common_options-flag--keep_state_after_build">--[no]keep_state_after_build</a></code> default: "true"</dt>
<dd>
<p>If false, Blaze will discard the inmemory state from this build when the build finishes. Subsequent builds will not have any incrementality with respect to this one.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="common_options-flag--skyframe_high_water_mark_full_gc_drops_per_invocation"><code id="skyframe_high_water_mark_full_gc_drops_per_invocation"><a href="#common_options-flag--skyframe_high_water_mark_full_gc_drops_per_invocation">--skyframe_high_water_mark_full_gc_drops_per_invocation</a>=&lt;an integer, &gt;= 0&gt;</code> default: "10"</dt>
<dd>
<p>Flag for advanced configuration of Bazel's internal Skyframe engine. If Bazel detects its retained heap percentage usage exceeds the threshold set by --skyframe_high_water_mark_threshold, when a full GC event occurs, it will drop unnecessary temporary Skyframe state, up to this many times per invocation. Defaults to 10. Zero means that full GC events will never trigger drops. If the limit is reached, Skyframe state will no longer be dropped when a full GC event occurs and that retained heap percentage threshold is exceeded.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="common_options-flag--skyframe_high_water_mark_minor_gc_drops_per_invocation"><code id="skyframe_high_water_mark_minor_gc_drops_per_invocation"><a href="#common_options-flag--skyframe_high_water_mark_minor_gc_drops_per_invocation">--skyframe_high_water_mark_minor_gc_drops_per_invocation</a>=&lt;an integer, &gt;= 0&gt;</code> default: "10"</dt>
<dd>
<p>Flag for advanced configuration of Bazel's internal Skyframe engine. If Bazel detects its retained heap percentage usage exceeds the threshold set by --skyframe_high_water_mark_threshold, when a minor GC event occurs, it will drop unnecessary temporary Skyframe state, up to this many times per invocation. Defaults to 10. Zero means that minor GC events will never trigger drops. If the limit is reached, Skyframe state will no longer be dropped when a minor GC event occurs and that retained heap percentage threshold is exceeded.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="common_options-flag--skyframe_high_water_mark_threshold"><code id="skyframe_high_water_mark_threshold"><a href="#common_options-flag--skyframe_high_water_mark_threshold">--skyframe_high_water_mark_threshold</a>=&lt;an integer&gt;</code> default: "85"</dt>
<dd>
<p>Flag for advanced configuration of Bazel's internal Skyframe engine. If Bazel detects its retained heap percentage usage is at least this threshold, it will drop unnecessary temporary Skyframe state. Tweaking this may let you mitigate wall time impact of GC thrashing, when the GC thrashing is (i) caused by the memory usage of this temporary state and (ii) more costly than reconstituting the state when it is needed.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="common_options-flag--track_incremental_state"><code id="track_incremental_state"><a href="#common_options-flag--track_incremental_state">--[no]track_incremental_state</a></code> default: "true"</dt>
<dd>
<p>If false, Blaze will not persist data that allows for invalidation and re-evaluation on incremental builds in order to save memory on this build. Subsequent builds will not have any incrementality with respect to this one. Usually you will want to specify --batch when setting this to false.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
</dl>
<dl>Options that affect the verbosity, format or location of logging:
<dt id="common_options-flag--announce_rc"><code id="announce_rc"><a href="#common_options-flag--announce_rc">--[no]announce_rc</a></code> default: "false"</dt>
<dd>
<p>Whether to announce rc options.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--attempt_to_print_relative_paths"><code id="attempt_to_print_relative_paths"><a href="#common_options-flag--attempt_to_print_relative_paths">--[no]attempt_to_print_relative_paths</a></code> default: "false"</dt>
<dd>
<p>When printing the location part of messages, attempt to use a path relative to the workspace directory or one of the directories specified by --package_path.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="common_options-flag--bes_backend"><code id="bes_backend"><a href="#common_options-flag--bes_backend">--bes_backend</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Specifies the build event service (BES) backend endpoint in the form
<code>[SCHEME://]HOST[:PORT]</code>. The default is to disable BES uploads. Supported schemes
are <code>grpc</code> and <code>grpcs</code> (grpc with TLS enabled). If no scheme is provided, Bazel
assumes <code>grpcs</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--bes_check_preceding_lifecycle_events"><code id="bes_check_preceding_lifecycle_events"><a href="#common_options-flag--bes_check_preceding_lifecycle_events">--[no]bes_check_preceding_lifecycle_events</a></code> default: "false"</dt>
<dd>
<p>Sets the field <code>check_preceding_lifecycle_events_present</code> on
<code>PublishBuildToolEventStreamRequest</code> which tells BES to check whether it previously
received <code>InvocationAttemptStarted</code> and <code>BuildEnqueued</code> events matching the current
tool event.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--bes_header"><code id="bes_header"><a href="#common_options-flag--bes_header">--bes_header</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specify a header in <code>NAME=VALUE</code> form that will be included in BES requests.
Multiple headers can be passed by specifying the flag multiple times. Multiple
values for the same name will be converted to a comma-separated list.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--bes_instance_name"><code id="bes_instance_name"><a href="#common_options-flag--bes_instance_name">--bes_instance_name</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specifies the instance name under which the BES will persist uploaded BEP. Defaults to null.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--bes_keywords"><code id="bes_keywords"><a href="#common_options-flag--bes_keywords">--bes_keywords</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies a list of notification keywords to be added the default set of keywords
published to BES (<code>command_name={command_name}</code>, <code>protocol_name=BEP</code>).
Defaults to none.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--bes_lifecycle_events"><code id="bes_lifecycle_events"><a href="#common_options-flag--bes_lifecycle_events">--[no]bes_lifecycle_events</a></code> default: "true"</dt>
<dd>
<p>Specifies whether to publish BES lifecycle events. (defaults to 'true').</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--bes_oom_finish_upload_timeout"><code id="bes_oom_finish_upload_timeout"><a href="#common_options-flag--bes_oom_finish_upload_timeout">--bes_oom_finish_upload_timeout</a>=&lt;An immutable length of time.&gt;</code> default: "10m"</dt>
<dd>
<p>Specifies how long bazel should wait for the BES/BEP upload to complete while OOMing. This flag ensures termination when the JVM is severely GC thrashing and cannot make progress on any user thread.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--bes_outerr_buffer_size"><code id="bes_outerr_buffer_size"><a href="#common_options-flag--bes_outerr_buffer_size">--bes_outerr_buffer_size</a>=&lt;an integer&gt;</code> default: "10240"</dt>
<dd>
<p>Specifies the maximal size of stdout or stderr to be buffered in BEP, before it is
reported as a progress event. Individual writes are still reported in a single
event, even if larger than the specified value up to <code>--bes_outerr_chunk_size</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--bes_outerr_chunk_size"><code id="bes_outerr_chunk_size"><a href="#common_options-flag--bes_outerr_chunk_size">--bes_outerr_chunk_size</a>=&lt;an integer&gt;</code> default: "1048576"</dt>
<dd>
<p>Specifies the maximal size of stdout or stderr to be sent to BEP in a single message.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--bes_proxy"><code id="bes_proxy"><a href="#common_options-flag--bes_proxy">--bes_proxy</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Connect to the Build Event Service through a proxy. Currently this flag can only be
used to configure a Unix domain socket (<code>unix:/path/to/socket</code>).</p>
</dd>
<dt id="common_options-flag--bes_results_url"><code id="bes_results_url"><a href="#common_options-flag--bes_results_url">--bes_results_url</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Specifies the base URL where a user can view the information streamed to the BES backend. Bazel will output the URL appended by the invocation id to the terminal.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="common_options-flag--bes_system_keywords"><code id="bes_system_keywords"><a href="#common_options-flag--bes_system_keywords">--bes_system_keywords</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies a list of notification keywords to be included directly, without the
<code>user_keyword=</code> prefix included for keywords supplied via <code>--bes_keywords</code>.
Intended for Build service operators that set <code>--bes_lifecycle_events=false</code> and
include keywords when calling <code>PublishLifecycleEvent</code>. Build service operators
using this flag should prevent users from overriding the flag value.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--bes_timeout"><code id="bes_timeout"><a href="#common_options-flag--bes_timeout">--bes_timeout</a>=&lt;An immutable length of time.&gt;</code> default: "0s"</dt>
<dd>
<p>Specifies how long bazel should wait for the BES/BEP upload to complete after the
build and tests have finished. A valid timeout is a natural number followed by a
unit: Days (d), hours (h), minutes (m), seconds (s), and milliseconds (ms). The
default value is <code>0</code> which means that there is no timeout.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--bes_upload_mode"><code id="bes_upload_mode"><a href="#common_options-flag--bes_upload_mode">--bes_upload_mode</a>=&lt;wait_for_upload_complete, nowait_for_upload_complete or fully_async&gt;</code> default: "wait_for_upload_complete"</dt>
<dd>
<p>Specifies whether the Build Event Service upload should block the build completion or
should end the invocation immediately and finish the upload in the
background.</p>
<ul>
<li><code>wait_for_upload_complete</code>: blocks at the end of the current invocation until
all events (including lifecycle events if applicable) are uploaded and
acknowledged by the backend.</li>
<li><code>nowait_for_upload_complete</code>: blocks at the beginning of the next invocation
until all events (including lifecycle events if applicable) are uploaded and
acknowledged by the backend.</li>
<li><code>fully_async</code>: blocks at the beginning of the next invocation until all events
are uploaded but does not wait for acknowledgements. Events may be lost in case
of (transient) failures and backends may report streams as incomplete in this
mode. There is no guarantee that <code>FinishInvocationAttempt</code> or <code>FinishBuild</code>
lifecycle events are sent.</li>
</ul>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="common_options-flag--build_event_binary_file"><code id="build_event_binary_file"><a href="#common_options-flag--build_event_binary_file">--build_event_binary_file</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>If non-empty, write a varint delimited binary representation of representation of the
build event protocol to that file. This option implies
<code>--bes_upload_mode=wait_for_upload_complete</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--build_event_binary_file_path_conversion"><code id="build_event_binary_file_path_conversion"><a href="#common_options-flag--build_event_binary_file_path_conversion">--[no]build_event_binary_file_path_conversion</a></code> default: "true"</dt>
<dd>
<p>Convert paths in the binary file representation of the build event protocol to more
globally valid URIs whenever possible; if disabled, the <code>file://</code> uri scheme will
always be used</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--build_event_binary_file_upload_mode"><code id="build_event_binary_file_upload_mode"><a href="#common_options-flag--build_event_binary_file_upload_mode">--build_event_binary_file_upload_mode</a>=&lt;wait_for_upload_complete, nowait_for_upload_complete or fully_async&gt;</code> default: "wait_for_upload_complete"</dt>
<dd>
<p>Specifies whether the Build Event Service upload for <code>--build_event_binary_file</code> should
block the build completion or should end the invocation immediately and finish
the upload in the background. Either <code>wait_for_upload_complete</code> (default),
<code>nowait_for_upload_complete</code>, or <code>fully_async</code>.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="common_options-flag--build_event_json_file"><code id="build_event_json_file"><a href="#common_options-flag--build_event_json_file">--build_event_json_file</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>If non-empty, write a JSON serialisation of the build event protocol to that file.
This option implies <code>--bes_upload_mode=wait_for_upload_complete</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--build_event_json_file_path_conversion"><code id="build_event_json_file_path_conversion"><a href="#common_options-flag--build_event_json_file_path_conversion">--[no]build_event_json_file_path_conversion</a></code> default: "true"</dt>
<dd>
<p>Convert paths in the json file representation of the build event protocol to more
globally valid URIs whenever possible; if disabled, the <code>file://</code> uri scheme will
always be used</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--build_event_json_file_upload_mode"><code id="build_event_json_file_upload_mode"><a href="#common_options-flag--build_event_json_file_upload_mode">--build_event_json_file_upload_mode</a>=&lt;wait_for_upload_complete, nowait_for_upload_complete or fully_async&gt;</code> default: "wait_for_upload_complete"</dt>
<dd>
<p>Specifies whether the Build Event Service upload for <code>--build_event_json_file</code> should
block the build completion or should end the invocation immediately and finish
the upload in the background. Either <code>wait_for_upload_complete</code> (default),
<code>nowait_for_upload_complete</code>, or <code>fully_async</code>.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="common_options-flag--build_event_max_named_set_of_file_entries"><code id="build_event_max_named_set_of_file_entries"><a href="#common_options-flag--build_event_max_named_set_of_file_entries">--build_event_max_named_set_of_file_entries</a>=&lt;an integer&gt;</code> default: "5000"</dt>
<dd>
<p>The maximum number of entries for a single <code>named_set_of_files</code> event; values smaller
than 2 are ignored and no event splitting is performed. This is intended for
limiting the maximum event size in the build event protocol, although it does not
directly control event size. The total event size is a function of the structure
of the set as well as the file and uri lengths, which may in turn depend on the
hash function.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--build_event_publish_all_actions"><code id="build_event_publish_all_actions"><a href="#common_options-flag--build_event_publish_all_actions">--[no]build_event_publish_all_actions</a></code> default: "false"</dt>
<dd>
<p>Whether all actions should be published.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--build_event_text_file"><code id="build_event_text_file"><a href="#common_options-flag--build_event_text_file">--build_event_text_file</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>If non-empty, write a textual representation of the build event protocol to that file</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--build_event_text_file_path_conversion"><code id="build_event_text_file_path_conversion"><a href="#common_options-flag--build_event_text_file_path_conversion">--[no]build_event_text_file_path_conversion</a></code> default: "true"</dt>
<dd>
<p>Convert paths in the text file representation of the build event protocol to more
globally valid URIs whenever possible; if disabled, the <code>file://</code> uri scheme will
always be used</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--build_event_text_file_upload_mode"><code id="build_event_text_file_upload_mode"><a href="#common_options-flag--build_event_text_file_upload_mode">--build_event_text_file_upload_mode</a>=&lt;wait_for_upload_complete, nowait_for_upload_complete or fully_async&gt;</code> default: "wait_for_upload_complete"</dt>
<dd>
<p>Specifies whether the Build Event Service upload for <code>--build_event_text_file</code> should
block the build completion or should end the invocation immediately and finish
the upload in the background. Either <code>wait_for_upload_complete</code> (default),
<code>nowait_for_upload_complete</code>, or <code>fully_async</code>.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="common_options-flag--build_event_upload_max_retries"><code id="build_event_upload_max_retries"><a href="#common_options-flag--build_event_upload_max_retries">--build_event_upload_max_retries</a>=&lt;an integer&gt;</code> default: "4"</dt>
<dd>
<p>The maximum number of times Bazel should retry uploading a build event.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="common_options-flag--experimental_bep_target_summary"><code id="experimental_bep_target_summary"><a href="#common_options-flag--experimental_bep_target_summary">--[no]experimental_bep_target_summary</a></code> default: "false"</dt>
<dd>
<p>Whether to publish <code>TargetSummary</code> events.</p>
</dd>
<dt id="common_options-flag--experimental_build_event_expand_filesets"><code id="experimental_build_event_expand_filesets"><a href="#common_options-flag--experimental_build_event_expand_filesets">--[no]experimental_build_event_expand_filesets</a></code> default: "false"</dt>
<dd>
<p>If true, expand Filesets in the BEP when presenting output files.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--experimental_build_event_output_group_mode"><code id="experimental_build_event_output_group_mode"><a href="#common_options-flag--experimental_build_event_output_group_mode">--experimental_build_event_output_group_mode</a>=&lt;an output group name followed by an OutputGroupFileMode, e.g. default=both&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specify how an output group's files will be represented in <code>TargetComplete</code>/<code>AspectComplete</code>
BEP events. Values are an assignment of an output group name to one of
<code>NAMED_SET_OF_FILES_ONLY</code>, <code>INLINE_ONLY</code>, or <code>BOTH</code>. The default value is
<code>NAMED_SET_OF_FILES_ONLY</code>. If an output group is repeated, the final value to
appear is used. The default value sets the mode for coverage artifacts to BOTH:
<code>--experimental_build_event_output_group_mode=baseline.lcov=both</code></p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--experimental_build_event_upload_retry_minimum_delay"><code id="experimental_build_event_upload_retry_minimum_delay"><a href="#common_options-flag--experimental_build_event_upload_retry_minimum_delay">--experimental_build_event_upload_retry_minimum_delay</a>=&lt;An immutable length of time.&gt;</code> default: "1s"</dt>
<dd>
<p>Initial, minimum delay for exponential backoff retries when BEP upload fails. (exponent: 1.6)</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="common_options-flag--experimental_build_event_upload_strategy"><code id="experimental_build_event_upload_strategy"><a href="#common_options-flag--experimental_build_event_upload_strategy">--experimental_build_event_upload_strategy</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Selects how to upload artifacts referenced in the build event protocol. In Bazel
the valid options include <code>local</code> and <code>remote</code>. The default value is <code>local</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--experimental_collect_load_average_in_profiler"><code id="experimental_collect_load_average_in_profiler"><a href="#common_options-flag--experimental_collect_load_average_in_profiler">--[no]experimental_collect_load_average_in_profiler</a></code> default: "true"</dt>
<dd>
<p>If enabled, the profiler collects the system's overall load average.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--experimental_collect_pressure_stall_indicators"><code id="experimental_collect_pressure_stall_indicators"><a href="#common_options-flag--experimental_collect_pressure_stall_indicators">--[no]experimental_collect_pressure_stall_indicators</a></code> default: "false"</dt>
<dd>
<p>If enabled, the profiler collects the Linux PSI data.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--experimental_collect_resource_estimation"><code id="experimental_collect_resource_estimation"><a href="#common_options-flag--experimental_collect_resource_estimation">--[no]experimental_collect_resource_estimation</a></code> default: "false"</dt>
<dd>
<p>If enabled, the profiler collects CPU and memory usage estimation for local actions.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--experimental_collect_skyframe_counts_in_profiler"><code id="experimental_collect_skyframe_counts_in_profiler"><a href="#common_options-flag--experimental_collect_skyframe_counts_in_profiler">--[no]experimental_collect_skyframe_counts_in_profiler</a></code> default: "false"</dt>
<dd>
<p>If enabled, the profiler collects SkyFunction counts in the Skyframe graph over time for key function types, like configured targets and action executions. May have a performance hit as this visits the ENTIRE Skyframe graph at every profiling time unit. Do not use this flag with performance-critical measurements.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--experimental_collect_system_network_usage"><code id="experimental_collect_system_network_usage"><a href="#common_options-flag--experimental_collect_system_network_usage">--[no]experimental_collect_system_network_usage</a></code> default: "true"</dt>
<dd>
<p>If enabled, the profiler collects the system's network usage.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--experimental_collect_worker_data_in_profiler"><code id="experimental_collect_worker_data_in_profiler"><a href="#common_options-flag--experimental_collect_worker_data_in_profiler">--[no]experimental_collect_worker_data_in_profiler</a></code> default: "true"</dt>
<dd>
<p>If enabled, the profiler collects worker's aggregated resource data.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--experimental_command_profile"><code id="experimental_command_profile"><a href="#common_options-flag--experimental_command_profile">--experimental_command_profile</a>=&lt;cpu, wall, alloc or lock&gt;</code> default: see description</dt>
<dd>
<p>Records a Java Flight Recorder profile for the duration of the command. One of the supported profiling event types (cpu, wall, alloc or lock) must be given as an argument. The profile is written to a file named after the event type under the output base directory. The syntax and semantics of this flag might change in the future to support additional profile types or output formats; use at your own risk.</p>
</dd>
<dt id="common_options-flag--experimental_profile_additional_tasks"><code id="experimental_profile_additional_tasks"><a href="#common_options-flag--experimental_profile_additional_tasks">--experimental_profile_additional_tasks</a>=&lt;phase, action, discover_inputs, action_check, action_lock, action_update, action_complete, action_rewinding, bzlmod, info, create_package, remote_execution, local_execution, scanner, local_parse, upload_time, remote_process_time, remote_queue, remote_setup, fetch, local_process_time, vfs_stat, vfs_dir, vfs_readlink, vfs_md5, vfs_xattr, vfs_delete, vfs_open, vfs_read, vfs_write, vfs_glob, vfs_vmfs_stat, vfs_vmfs_dir, vfs_vmfs_read, wait, thread_name, thread_sort_index, skyframe_eval, skyfunction, critical_path, critical_path_component, handle_gc_notification, local_action_counts, starlark_parser, starlark_user_fn, starlark_builtin_fn, starlark_user_compiled_fn, starlark_repository_fn, starlark_thread_context, action_fs_staging, remote_cache_check, remote_download, remote_network, filesystem_traversal, worker_execution, worker_setup, worker_borrow, worker_working, worker_copying_outputs, credential_helper, conflict_check, dynamic_lock, repository_fetch, repository_vendor, repo_cache_gc_wait, spawn_log, rpc, skycache, wasm_load, wasm_exec or unknown&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies additional profile tasks to be included in the profile.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--experimental_profile_include_primary_output"><code id="experimental_profile_include_primary_output"><a href="#common_options-flag--experimental_profile_include_primary_output">--[no]experimental_profile_include_primary_output</a></code> default: "false"</dt>
<dd>
<p>Includes the extra &quot;out&quot; attribute in action events that contains the exec path to the action's primary output.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--experimental_profile_include_target_configuration"><code id="experimental_profile_include_target_configuration"><a href="#common_options-flag--experimental_profile_include_target_configuration">--[no]experimental_profile_include_target_configuration</a></code> default: "false"</dt>
<dd>
<p>Includes target configuration hash in action events' JSON profile data.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--experimental_profile_include_target_label"><code id="experimental_profile_include_target_label"><a href="#common_options-flag--experimental_profile_include_target_label">--[no]experimental_profile_include_target_label</a></code> default: "false"</dt>
<dd>
<p>Includes target label in action events' JSON profile data.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--experimental_record_metrics_for_all_mnemonics"><code id="experimental_record_metrics_for_all_mnemonics"><a href="#common_options-flag--experimental_record_metrics_for_all_mnemonics">--[no]experimental_record_metrics_for_all_mnemonics</a></code> default: "false"</dt>
<dd>
<p>Controls the output of BEP ActionSummary and BuildGraphMetrics, limiting the number of mnemonics in ActionData and number of entries reported in BuildGraphMetrics.AspectCount/RuleClassCount. By default the number of types is limited to the top 20, by number of executed actions for ActionData, and instances for RuleClass and Asepcts. Setting this option will write statistics for all mnemonics, rule classes and aspects.</p>
</dd>
<dt id="common_options-flag--experimental_record_skyframe_metrics"><code id="experimental_record_skyframe_metrics"><a href="#common_options-flag--experimental_record_skyframe_metrics">--[no]experimental_record_skyframe_metrics</a></code> default: "false"</dt>
<dd>
<p>Controls the output of BEP BuildGraphMetrics, including expensiveto compute skyframe metrics about Skykeys, RuleClasses and Aspects.With this flag set to false BuildGraphMetrics.rule_count and aspectfields will not be populated in the BEP.</p>
</dd>
<dt id="common_options-flag--experimental_run_bep_event_include_residue"><code id="experimental_run_bep_event_include_residue"><a href="#common_options-flag--experimental_run_bep_event_include_residue">--[no]experimental_run_bep_event_include_residue</a></code> default: "false"</dt>
<dd>
<p>Whether to include the command-line residue in run build events which could contain the residue. By default, the residue is not included in run command build events that could contain the residue.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--experimental_stream_log_file_uploads"><code id="experimental_stream_log_file_uploads"><a href="#common_options-flag--experimental_stream_log_file_uploads">--[no]experimental_stream_log_file_uploads</a></code> default: "false"</dt>
<dd>
<p>Stream log file uploads directly to the remote storage rather than writing them to disk.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--experimental_workspace_rules_log_file"><code id="experimental_workspace_rules_log_file"><a href="#common_options-flag--experimental_workspace_rules_log_file">--experimental_workspace_rules_log_file</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>Log certain Workspace Rules events into this file as delimited WorkspaceEvent protos.</p>
</dd>
<dt id="common_options-flag--generate_json_trace_profile"><code id="generate_json_trace_profile"><a href="#common_options-flag--generate_json_trace_profile">--[no]generate_json_trace_profile</a></code> default: "auto"</dt>
<dd>
<p>If enabled, Bazel profiles the build and writes a JSON-format profile into a file in the output base. View profile by loading into chrome://tracing. By default Bazel writes the profile for all build-like commands and query.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--heap_dump_on_oom"><code id="heap_dump_on_oom"><a href="#common_options-flag--heap_dump_on_oom">--[no]heap_dump_on_oom</a></code> default: "false"</dt>
<dd>
<p>Whether to manually output a heap dump if an OOM is thrown (including manual OOMs due to reaching --gc_thrashing_limits). The dump will be written to &lt;output_base&gt;/&lt;invocation_id&gt;.heapdump.hprof. This option effectively replaces -XX:+HeapDumpOnOutOfMemoryError, which has no effect for manual OOMs.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--jvm_heap_histogram_internal_object_pattern"><code id="jvm_heap_histogram_internal_object_pattern"><a href="#common_options-flag--jvm_heap_histogram_internal_object_pattern">--jvm_heap_histogram_internal_object_pattern</a>=&lt;a valid Java regular expression&gt;</code> default: "jdk\.internal\.vm\.Filler.+"</dt>
<dd>
<p>Regex for overriding the matching logic for JDK21+ JVM heap memory collection. We are relying on volatile internal G1 GC implemenation details to get a clean memory metric, this option allows us to adapt to changes in that internal implementation without having to wait for a binary release.  Passed to JDK Matcher.find()</p>
</dd>
<dt id="common_options-flag--legacy_important_outputs"><code id="legacy_important_outputs"><a href="#common_options-flag--legacy_important_outputs">--[no]legacy_important_outputs</a></code> default: "false"</dt>
<dd>
<p>Use this to suppress generation of the legacy <code>important_outputs</code> field in the
<code>TargetComplete</code> event. <code>important_outputs</code> are required for Bazel to ResultStore/BTX
integration.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--logging"><code id="logging"><a href="#common_options-flag--logging">--logging</a>=&lt;0 &lt;= an integer &lt;= 6&gt;</code> default: "3"</dt>
<dd>
<p>The logging level.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--memory_profile"><code id="memory_profile"><a href="#common_options-flag--memory_profile">--memory_profile</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>If set, write memory usage data to the specified file at phase ends and stable heap to master log at end of build.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--memory_profile_stable_heap_parameters"><code id="memory_profile_stable_heap_parameters"><a href="#common_options-flag--memory_profile_stable_heap_parameters">--memory_profile_stable_heap_parameters</a>=&lt;integers, separated by a comma expected in pairs&gt;</code> default: "1,0"</dt>
<dd>
<p>Tune memory profile's computation of stable heap at end of build. Should be and even number of  integers separated by commas. In each pair the first integer is the number of GCs to perform. The second integer in each pair is the number of seconds to wait between GCs. Ex: 2,4,4,0 would 2 GCs with a 4sec pause, followed by 4 GCs with zero second pause</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--profile"><code id="profile"><a href="#common_options-flag--profile">--profile</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>If set, profile Bazel and write data to the specified file. See https://bazel.build/advanced/performance/json-trace-profile for more information.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--profiles_to_retain"><code id="profiles_to_retain"><a href="#common_options-flag--profiles_to_retain">--profiles_to_retain</a>=&lt;an integer&gt;</code> default: "5"</dt>
<dd>
<p>Number of profiles to retain in the output base. If there are more than this number of profiles in the output base, the oldest are deleted until the total is under the limit.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--record_full_profiler_data"><code id="record_full_profiler_data"><a href="#common_options-flag--record_full_profiler_data">--[no]record_full_profiler_data</a></code> default: "false"</dt>
<dd>
<p>By default, Bazel profiler will record only aggregated data for fast but numerous events (such as statting the file). If this option is enabled, profiler will record each event - resulting in more precise profiling data but LARGE performance hit. Option only has effect if --profile used as well.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--redirect_local_instrumentation_output_writes"><code id="redirect_local_instrumentation_output_writes"><a href="#common_options-flag--redirect_local_instrumentation_output_writes">--[no]redirect_local_instrumentation_output_writes</a></code> default: "false"</dt>
<dd>
<p>If true and supported, instrumentation output is redirected to be written locally on a different machine than where bazel is running on.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--remote_print_execution_messages"><code id="remote_print_execution_messages"><a href="#common_options-flag--remote_print_execution_messages">--remote_print_execution_messages</a>=&lt;failure, success or all&gt;</code> default: "failure"</dt>
<dd>
<p>Choose when to print remote execution messages. Valid values are <code>failure</code>, to print only on failures, <code>success</code> to print only on successes and <code>all</code> to print always.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="common_options-flag--slim_profile"><code id="slim_profile"><a href="#common_options-flag--slim_profile">--[no]slim_profile</a></code> default: "true"</dt>
<dd>
<p>Slims down the size of the JSON profile by merging events if the profile gets too large.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--starlark_cpu_profile"><code id="starlark_cpu_profile"><a href="#common_options-flag--starlark_cpu_profile">--starlark_cpu_profile</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Writes into the specified file a pprof profile of CPU usage by all Starlark threads.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--tool_tag"><code id="tool_tag"><a href="#common_options-flag--tool_tag">--tool_tag</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>A tool name to attribute this Bazel invocation to.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--ui_event_filters"><code id="ui_event_filters"><a href="#common_options-flag--ui_event_filters">--ui_event_filters</a>=&lt;Convert list of comma separated event kind to list of filters&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies which events to show in the UI. It is possible to add or remove events to the default ones using leading +/-, or override the default set completely with direct assignment. The set of supported event kinds include INFO, DEBUG, ERROR and more.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="common_options-flag--write_command_log"><code id="write_command_log"><a href="#common_options-flag--write_command_log">--[no]write_command_log</a></code> default: "false"</dt>
<dd>
<p>Whether or not to write the command.log file</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
</dl>
<dl>Remote caching and execution options:
<dt id="common_options-flag--downloader_config"><code id="downloader_config"><a href="#common_options-flag--downloader_config">--downloader_config</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>Specify a file to configure the remote downloader with. This file consists of lines, each of which starts with a directive (<code>allow</code>, <code>block</code> or <code>rewrite</code>) followed by either a host name (for <code>allow</code> and <code>block</code>) or two patterns, one to match against, and one to use as a substitute URL, with back-references starting from <code>$1</code>. It is possible for multiple <code>rewrite</code> directives for the same URL to be given, and in this case multiple URLs will be returned.</p>
</dd>
<dt id="common_options-flag--experimental_circuit_breaker_strategy"><code id="experimental_circuit_breaker_strategy"><a href="#common_options-flag--experimental_circuit_breaker_strategy">--experimental_circuit_breaker_strategy</a>=&lt;failure&gt;</code> default: see description</dt>
<dd>
<p>Specifies the strategy for the circuit breaker to use. Available strategies are &quot;failure&quot;. On invalid value for the option the behavior same as the option is not set.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="common_options-flag--experimental_remote_cache_compression_threshold"><code id="experimental_remote_cache_compression_threshold"><a href="#common_options-flag--experimental_remote_cache_compression_threshold">--experimental_remote_cache_compression_threshold</a>=&lt;an integer&gt;</code> default: "100"</dt>
<dd>
<p>The minimum blob size required to compress/decompress with zstd. Ineffectual unless --remote_cache_compression is set.</p>
</dd>
<dt id="common_options-flag--experimental_remote_cache_lease_extension"><code id="experimental_remote_cache_lease_extension"><a href="#common_options-flag--experimental_remote_cache_lease_extension">--[no]experimental_remote_cache_lease_extension</a></code> default: "false"</dt>
<dd>
<p>If set to true, Bazel will extend the lease for outputs of remote actions during the build by sending <code>FindMissingBlobs</code> calls periodically to remote cache. The frequency is based on the value of <code>--experimental_remote_cache_ttl</code>.</p>
</dd>
<dt id="common_options-flag--experimental_remote_cache_ttl"><code id="experimental_remote_cache_ttl"><a href="#common_options-flag--experimental_remote_cache_ttl">--experimental_remote_cache_ttl</a>=&lt;An immutable length of time.&gt;</code> default: "3h"</dt>
<dd>
<p>The guaranteed minimal TTL of blobs in the remote cache after their digests are recently referenced e.g. by an ActionResult or FindMissingBlobs. Bazel does several optimizations based on the blobs' TTL e.g. doesn't repeatedly call GetActionResult in an incremental build. The value should be set slightly less than the real TTL since there is a gap between when the server returns the digests and when Bazel receives them.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="common_options-flag--experimental_remote_capture_corrupted_outputs"><code id="experimental_remote_capture_corrupted_outputs"><a href="#common_options-flag--experimental_remote_capture_corrupted_outputs">--experimental_remote_capture_corrupted_outputs</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>A path to a directory where the corrupted outputs will be captured to.</p>
</dd>
<dt id="common_options-flag--experimental_remote_discard_merkle_trees"><code id="experimental_remote_discard_merkle_trees"><a href="#common_options-flag--experimental_remote_discard_merkle_trees">--[no]experimental_remote_discard_merkle_trees</a></code> default: "true"</dt>
<dd>
<p>If set to true, discard in-memory copies of the input root's Merkle tree and associated input mappings during calls to GetActionResult() and Execute(). This reduces memory usage significantly, but does require Bazel to recompute them upon remote cache misses and retries.</p>
</dd>
<dt id="common_options-flag--experimental_remote_downloader"><code id="experimental_remote_downloader"><a href="#common_options-flag--experimental_remote_downloader">--experimental_remote_downloader</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>A Remote Asset API endpoint URI, to be used as a remote download proxy. The supported schemas are grpc, grpcs (grpc with TLS enabled) and unix (local UNIX sockets). If no schema is provided Bazel will default to grpcs. See: https://github.com/bazelbuild/remote-apis/blob/master/build/bazel/remote/asset/v1/remote_asset.proto</p>
</dd>
<dt id="common_options-flag--experimental_remote_downloader_local_fallback"><code id="experimental_remote_downloader_local_fallback"><a href="#common_options-flag--experimental_remote_downloader_local_fallback">--[no]experimental_remote_downloader_local_fallback</a></code> default: "false"</dt>
<dd>
<p>Whether to fall back to the local downloader if remote downloader fails.</p>
</dd>
<dt id="common_options-flag--experimental_remote_downloader_propagate_credentials"><code id="experimental_remote_downloader_propagate_credentials"><a href="#common_options-flag--experimental_remote_downloader_propagate_credentials">--[no]experimental_remote_downloader_propagate_credentials</a></code> default: "false"</dt>
<dd>
<p>Whether to propagate credentials from netrc and credential helper to the remote downloader server. The server implementation needs to support the new <code>http_header_url:&amp;lt;url-index&amp;gt;:&amp;lt;header-key&amp;gt;</code> qualifier where the <code>&amp;lt;url-index&amp;gt;</code> is a 0-based position of the URL inside the FetchBlobRequest's <code>uris</code> field. The URL-specific headers should take precedence over the global headers.</p>
</dd>
<dt id="common_options-flag--experimental_remote_execution_keepalive"><code id="experimental_remote_execution_keepalive"><a href="#common_options-flag--experimental_remote_execution_keepalive">--[no]experimental_remote_execution_keepalive</a></code> default: "false"</dt>
<dd>
<p>Whether to use keepalive for remote execution calls.</p>
</dd>
<dt id="common_options-flag--experimental_remote_failure_rate_threshold"><code id="experimental_remote_failure_rate_threshold"><a href="#common_options-flag--experimental_remote_failure_rate_threshold">--experimental_remote_failure_rate_threshold</a>=&lt;an integer in 0-100 range&gt;</code> default: "10"</dt>
<dd>
<p>Sets the allowed number of failure rate in percentage for a specific time window after which it stops calling to the remote cache/executor. By default the value is 10. Setting this to 0 means no limitation.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="common_options-flag--experimental_remote_failure_window_interval"><code id="experimental_remote_failure_window_interval"><a href="#common_options-flag--experimental_remote_failure_window_interval">--experimental_remote_failure_window_interval</a>=&lt;An immutable length of time.&gt;</code> default: "60s"</dt>
<dd>
<p>The interval in which the failure rate of the remote requests are computed. On zero or negative value the failure duration is computed the whole duration of the execution.Following units can be used: Days (d), hours (h), minutes (m), seconds (s), and milliseconds (ms). If the unit is omitted, the value is interpreted as seconds.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="common_options-flag--experimental_remote_mark_tool_inputs"><code id="experimental_remote_mark_tool_inputs"><a href="#common_options-flag--experimental_remote_mark_tool_inputs">--[no]experimental_remote_mark_tool_inputs</a></code> default: "false"</dt>
<dd>
<p>If set to true, Bazel will mark inputs as tool inputs for the remote executor. This can be used to implement remote persistent workers.</p>
</dd>
<dt id="common_options-flag--experimental_remote_output_service"><code id="experimental_remote_output_service"><a href="#common_options-flag--experimental_remote_output_service">--experimental_remote_output_service</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>HOST or HOST:PORT of a remote output service endpoint. The supported schemas are grpc, grpcs (grpc with TLS enabled) and unix (local UNIX sockets). If no schema is provided Bazel will default to grpcs. Specify grpc:// or unix: schema to disable TLS.</p>
</dd>
<dt id="common_options-flag--experimental_remote_output_service_output_path_prefix"><code id="experimental_remote_output_service_output_path_prefix"><a href="#common_options-flag--experimental_remote_output_service_output_path_prefix">--experimental_remote_output_service_output_path_prefix</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The path under which the contents of output directories managed by the --experimental_remote_output_service are placed. The actual output directory used by a build will be a descendant of this path and determined by the output service.</p>
</dd>
<dt id="common_options-flag--experimental_remote_require_cached"><code id="experimental_remote_require_cached"><a href="#common_options-flag--experimental_remote_require_cached">--[no]experimental_remote_require_cached</a></code> default: "false"</dt>
<dd>
<p>If set to true, enforce that all actions that can run remotely are cached, or else fail the build. This is useful to troubleshoot non-determinism issues as it allows checking whether actions that should be cached are actually cached without spuriously injecting new results into the cache.</p>
</dd>
<dt id="common_options-flag--experimental_remote_scrubbing_config"><code id="experimental_remote_scrubbing_config"><a href="#common_options-flag--experimental_remote_scrubbing_config">--experimental_remote_scrubbing_config</a>=&lt;Converts to a Scrubber&gt;</code> default: see description</dt>
<dd>
<p>Enables remote cache key scrubbing with the supplied configuration file, which must be a protocol buffer in text format (see src/main/protobuf/remote_scrubbing.proto).</p>
<p>This feature is intended to facilitate sharing a remote/disk cache between actions executing on different platforms but targeting the same platform. It should be used with extreme care, as improper settings may cause accidental sharing of cache entries and result in incorrect builds.</p>
<p>Scrubbing does not affect how an action is executed, only how its remote/disk cache key is computed for the purpose of retrieving or storing an action result. Scrubbed actions are incompatible with remote execution, and will always be executed locally instead.</p>
<p>Modifying the scrubbing configuration does not invalidate outputs present in the local filesystem or internal caches; a clean build is required to reexecute affected actions.</p>
<p>In order to successfully use this feature, you likely want to set a custom --host_platform together with --experimental_platform_in_output_dir (to normalize output prefixes) and --incompatible_strict_action_env (to normalize environment variables).</p>
</dd>
<dt id="common_options-flag--guard_against_concurrent_changes"><code id="guard_against_concurrent_changes"><a href="#common_options-flag--guard_against_concurrent_changes">--[no]guard_against_concurrent_changes</a></code> default: "lite"</dt>
<dd>
<p>Set this to 'full' to enable checking the ctime of all input files of an action before uploading it to a remote cache. There may be cases where the Linux kernel delays writing of files, which could cause false positives. The default is 'lite', which only checks source files in the main repository. Setting this to 'off' disables all checks. This is not recommended, as the cache may be polluted when a source file is changed while an action that takes it as an input is executing.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="common_options-flag--remote_accept_cached"><code id="remote_accept_cached"><a href="#common_options-flag--remote_accept_cached">--[no]remote_accept_cached</a></code> default: "true"</dt>
<dd>
<p>Whether to accept remotely cached action results.</p>
</dd>
<dt id="common_options-flag--remote_build_event_upload"><code id="remote_build_event_upload"><a href="#common_options-flag--remote_build_event_upload">--remote_build_event_upload</a>=&lt;all or minimal&gt;</code> default: "minimal"</dt>
<dd>
<p>If set to 'all', all local outputs referenced by BEP are uploaded to remote cache.
If set to 'minimal', local outputs referenced by BEP are not uploaded to the remote cache, except for files that are important to the consumers of BEP (e.g. test logs and timing profile). bytestream:// scheme is always used for the uri of files even if they are missing from remote cache.
Default to 'minimal'.</p>
</dd>
<dt id="common_options-flag--remote_bytestream_uri_prefix"><code id="remote_bytestream_uri_prefix"><a href="#common_options-flag--remote_bytestream_uri_prefix">--remote_bytestream_uri_prefix</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The hostname and instance name to be used in bytestream:// URIs that are written into build event streams. This option can be set when builds are performed using a proxy, which causes the values of --remote_executor and --remote_instance_name to no longer correspond to the canonical name of the remote execution service. When not set, it will default to &quot;${hostname}/${instance_name}&quot;.</p>
</dd>
<dt id="common_options-flag--remote_cache"><code id="remote_cache"><a href="#common_options-flag--remote_cache">--remote_cache</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>A URI of a caching endpoint. The supported schemas are http, https, grpc, grpcs (grpc with TLS enabled) and unix (local UNIX sockets). If no schema is provided Bazel will default to grpcs. Specify grpc://, http:// or unix: schema to disable TLS. See https://bazel.build/remote/caching</p>
</dd>
<dt id="common_options-flag--remote_cache_async"><code id="remote_cache_async"><a href="#common_options-flag--remote_cache_async">--[no]remote_cache_async</a></code> default: "true"</dt>
<dd>
<p>If true, uploading of action results to a disk or remote cache will happen in the background instead of blocking the completion of an action. Some actions are incompatible with background uploads, and may still block even when this flag is set.</p>
</dd>
<dt id="common_options-flag--remote_cache_compression"><code id="remote_cache_compression"><a href="#common_options-flag--remote_cache_compression">--[no]remote_cache_compression</a></code> default: "false"</dt>
<dd>
<p>If enabled, compress/decompress cache blobs with zstd when their size is at least --experimental_remote_cache_compression_threshold.</p>
</dd>
<dt id="common_options-flag--remote_cache_header"><code id="remote_cache_header"><a href="#common_options-flag--remote_cache_header">--remote_cache_header</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specify a header that will be included in cache requests: --remote_cache_header=Name=Value. Multiple headers can be passed by specifying the flag multiple times. Multiple values for the same name will be converted to a comma-separated list.</p>
</dd>
<dt id="common_options-flag--remote_default_exec_properties"><code id="remote_default_exec_properties"><a href="#common_options-flag--remote_default_exec_properties">--remote_default_exec_properties</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Set the default exec properties to be used as the remote execution platform if an execution platform does not already set exec_properties.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--remote_default_platform_properties"><code id="remote_default_platform_properties"><a href="#common_options-flag--remote_default_platform_properties">--remote_default_platform_properties</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Set the default platform properties to be set for the remote execution API, if the execution platform does not already set remote_execution_properties. This value will also be used if the host platform is selected as the execution platform for remote execution.</p>
</dd>
<dt id="common_options-flag--remote_download_regex"><code id="remote_download_regex"><a href="#common_options-flag--remote_download_regex">--remote_download_regex</a>=&lt;a valid Java regular expression&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Force remote build outputs whose path matches this pattern to be downloaded, irrespective of --remote_download_outputs. Multiple patterns may be specified by repeating this flag.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="common_options-flag--remote_downloader_header"><code id="remote_downloader_header"><a href="#common_options-flag--remote_downloader_header">--remote_downloader_header</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specify a header that will be included in remote downloader requests: --remote_downloader_header=Name=Value. Multiple headers can be passed by specifying the flag multiple times. Multiple values for the same name will be converted to a comma-separated list.</p>
</dd>
<dt id="common_options-flag--remote_exec_header"><code id="remote_exec_header"><a href="#common_options-flag--remote_exec_header">--remote_exec_header</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specify a header that will be included in execution requests: --remote_exec_header=Name=Value. Multiple headers can be passed by specifying the flag multiple times. Multiple values for the same name will be converted to a comma-separated list.</p>
</dd>
<dt id="common_options-flag--remote_execution_priority"><code id="remote_execution_priority"><a href="#common_options-flag--remote_execution_priority">--remote_execution_priority</a>=&lt;an integer&gt;</code> default: "0"</dt>
<dd>
<p>The relative priority of actions to be executed remotely. The semantics of the particular priority values are server-dependent.</p>
</dd>
<dt id="common_options-flag--remote_executor"><code id="remote_executor"><a href="#common_options-flag--remote_executor">--remote_executor</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>HOST or HOST:PORT of a remote execution endpoint. The supported schemas are grpc, grpcs (grpc with TLS enabled) and unix (local UNIX sockets). If no schema is provided Bazel will default to grpcs. Specify grpc:// or unix: schema to disable TLS.</p>
</dd>
<dt id="common_options-flag--remote_grpc_log"><code id="remote_grpc_log"><a href="#common_options-flag--remote_grpc_log">--remote_grpc_log</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>If specified, a path to a file to log gRPC call related details. This log consists of a sequence of serialized com.google.devtools.build.lib.remote.logging.RemoteExecutionLog.LogEntry protobufs with each message prefixed by a varint denoting the size of the following serialized protobuf message, as performed by the method LogEntry.writeDelimitedTo(OutputStream).</p>
</dd>
<dt id="common_options-flag--remote_header"><code id="remote_header"><a href="#common_options-flag--remote_header">--remote_header</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specify a header that will be included in requests: --remote_header=Name=Value. Multiple headers can be passed by specifying the flag multiple times. Multiple values for the same name will be converted to a comma-separated list.</p>
</dd>
<dt id="common_options-flag--remote_instance_name"><code id="remote_instance_name"><a href="#common_options-flag--remote_instance_name">--remote_instance_name</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Value to pass as instance_name in the remote execution API.</p>
</dd>
<dt id="common_options-flag--remote_local_fallback"><code id="remote_local_fallback"><a href="#common_options-flag--remote_local_fallback">--[no]remote_local_fallback</a></code> default: "false"</dt>
<dd>
<p>Whether to fall back to standalone local execution strategy if remote execution fails.</p>
</dd>
<dt id="common_options-flag--remote_local_fallback_strategy"><code id="remote_local_fallback_strategy"><a href="#common_options-flag--remote_local_fallback_strategy">--remote_local_fallback_strategy</a>=&lt;a string&gt;</code> default: "local"</dt>
<dd>
<p>Deprecated. See https://github.com/bazelbuild/bazel/issues/7480 for details.</p>
</dd>
<dt id="common_options-flag--remote_max_connections"><code id="remote_max_connections"><a href="#common_options-flag--remote_max_connections">--remote_max_connections</a>=&lt;an integer&gt;</code> default: "100"</dt>
<dd>
<p>Limit the max number of concurrent connections to remote cache/executor. By default the value is 100. Setting this to 0 means no limitation.
For HTTP remote cache, one TCP connection could handle one request at one time, so Bazel could make up to --remote_max_connections concurrent requests.
For gRPC remote cache/executor, one gRPC channel could usually handle 100+ concurrent requests, so Bazel could make around <code>--remote_max_connections * 100</code> concurrent requests.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="common_options-flag--remote_proxy"><code id="remote_proxy"><a href="#common_options-flag--remote_proxy">--remote_proxy</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Connect to the remote cache through a proxy. Currently this flag can only be used to configure a Unix domain socket (unix:/path/to/socket).</p>
</dd>
<dt id="common_options-flag--remote_result_cache_priority"><code id="remote_result_cache_priority"><a href="#common_options-flag--remote_result_cache_priority">--remote_result_cache_priority</a>=&lt;an integer&gt;</code> default: "0"</dt>
<dd>
<p>The relative priority of remote actions to be stored in remote cache. The semantics of the particular priority values are server-dependent.</p>
</dd>
<dt id="common_options-flag--remote_retries"><code id="remote_retries"><a href="#common_options-flag--remote_retries">--remote_retries</a>=&lt;an integer&gt;</code> default: "5"</dt>
<dd>
<p>The maximum number of attempts to retry a transient error. If set to 0, retries are disabled.</p>
</dd>
<dt id="common_options-flag--remote_retry_max_delay"><code id="remote_retry_max_delay"><a href="#common_options-flag--remote_retry_max_delay">--remote_retry_max_delay</a>=&lt;An immutable length of time.&gt;</code> default: "5s"</dt>
<dd>
<p>The maximum backoff delay between remote retry attempts. Following units can be used: Days (d), hours (h), minutes (m), seconds (s), and milliseconds (ms). If the unit is omitted, the value is interpreted as seconds.</p>
</dd>
<dt id="common_options-flag--remote_timeout"><code id="remote_timeout"><a href="#common_options-flag--remote_timeout">--remote_timeout</a>=&lt;An immutable length of time.&gt;</code> default: "60s"</dt>
<dd>
<p>The maximum amount of time to wait for remote execution and cache calls. For the REST cache, this is both the connect and the read timeout. Following units can be used: Days (d), hours (h), minutes (m), seconds (s), and milliseconds (ms). If the unit is omitted, the value is interpreted as seconds.</p>
</dd>
<dt id="common_options-flag--remote_upload_local_results"><code id="remote_upload_local_results"><a href="#common_options-flag--remote_upload_local_results">--[no]remote_upload_local_results</a></code> default: "true"</dt>
<dd>
<p>Whether to upload locally executed action results to the remote cache if the remote cache supports it and the user is authorized to do so.</p>
</dd>
<dt id="common_options-flag--remote_verify_downloads"><code id="remote_verify_downloads"><a href="#common_options-flag--remote_verify_downloads">--[no]remote_verify_downloads</a></code> default: "true"</dt>
<dd>
<p>If set to true, Bazel will compute the hash sum of all remote downloads and  discard the remotely cached values if they don't match the expected value.</p>
</dd>
</dl>
<dl>Miscellaneous options, not otherwise categorized.:
<dt id="common_options-flag--build_metadata"><code id="build_metadata"><a href="#common_options-flag--build_metadata">--build_metadata</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Custom key-value string pairs to supply in a build event.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="common_options-flag--color"><code id="color"><a href="#common_options-flag--color">--color</a>=&lt;yes, no or auto&gt;</code> default: "auto"</dt>
<dd>
<p>Use terminal controls to colorize output.</p>
</dd>
<dt id="common_options-flag--config"><code id="config"><a href="#common_options-flag--config">--config</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Selects additional config sections from the rc files; for every &lt;command&gt;, it also pulls in the options from &lt;command&gt;:&lt;config&gt; if such a section exists; if this section doesn't exist in any .rc file, Blaze fails with an error. The config sections and flag combinations they are equivalent to are located in the tools/*.blazerc config files.</p>
</dd>
<dt id="common_options-flag--credential_helper"><code id="credential_helper"><a href="#common_options-flag--credential_helper">--credential_helper</a>=&lt;Path to a credential helper. It may be absolute, relative to the PATH environment variable, or %workspace%-relative. The path be optionally prefixed by a scope  followed by an &#39;=&#39;. The scope is a domain name, optionally with a single leading &#39;*&#39; wildcard component. A helper applies to URIs matching its scope, with more specific scopes preferred. If a helper has no scope, it applies to every URI.&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Configures a credential helper conforming to the <a href="https://github.com/EngFlow/credential-helper-spec">Credential Helper Specification</a>
to use for retrieving authorization credentials for repository
fetching, remote caching and execution, and the build event service.</p>
<p>Credentials supplied by a helper take precedence over credentials supplied by
<code>--google_default_credentials</code>, <code>--google_credentials</code>, a <code>.netrc</code> file, or the
auth parameter to <code>repository_ctx.download()</code> and
<code>repository_ctx.download_and_extract()</code>.</p>
<p>May be specified multiple times to set up multiple helpers.</p>
<p>See <a href="https://blog.engflow.com/2023/10/09/configuring-bazels-credential-helper/">Configuring Bazel's Credential Helper - Engflow Blog</a> for instructions.</p>
</dd>
<dt id="common_options-flag--credential_helper_cache_duration"><code id="credential_helper_cache_duration"><a href="#common_options-flag--credential_helper_cache_duration">--credential_helper_cache_duration</a>=&lt;An immutable length of time.&gt;</code> default: "30m"</dt>
<dd>
<p>How long to cache credentials for if the credential helper doesn't return an expiration time. Changing the value of this flag clears the cache.</p>
</dd>
<dt id="common_options-flag--credential_helper_timeout"><code id="credential_helper_timeout"><a href="#common_options-flag--credential_helper_timeout">--credential_helper_timeout</a>=&lt;An immutable length of time.&gt;</code> default: "10s"</dt>
<dd>
<p>Configures the timeout for a credential helper.</p>
<p>Credential helpers failing to respond within this timeout will fail the invocation.</p>
</dd>
<dt id="common_options-flag--curses"><code id="curses"><a href="#common_options-flag--curses">--curses</a>=&lt;yes, no or auto&gt;</code> default: "auto"</dt>
<dd>
<p>Use terminal cursor controls to minimize scrolling output.</p>
</dd>
<dt id="common_options-flag--disk_cache"><code id="disk_cache"><a href="#common_options-flag--disk_cache">--disk_cache</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>A path to a directory where Bazel can read and write actions and action outputs. If the directory does not exist, it will be created.</p>
</dd>
<dt id="common_options-flag--enable_platform_specific_config"><code id="enable_platform_specific_config"><a href="#common_options-flag--enable_platform_specific_config">--[no]enable_platform_specific_config</a></code> default: "true"</dt>
<dd>
<p>If true, Bazel picks up host-OS-specific config lines from bazelrc files. For example, if the host OS is Linux and you run bazel build, Bazel picks up lines starting with build:linux. Supported OS identifiers are linux, macos, windows, freebsd, and openbsd. Enabling this flag is equivalent to using --config=linux on Linux, --config=windows on Windows, etc.</p>
</dd>
<dt id="common_options-flag--experimental_action_cache_gc_idle_delay"><code id="experimental_action_cache_gc_idle_delay"><a href="#common_options-flag--experimental_action_cache_gc_idle_delay">--experimental_action_cache_gc_idle_delay</a>=&lt;An immutable length of time.&gt;</code> default: "5m"</dt>
<dd>
<p>How long the server must remain idle before a garbage collection of the action cache is attempted. Ineffectual unless --experimental_action_cache_gc_max_age is nonzero.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="common_options-flag--experimental_action_cache_gc_max_age"><code id="experimental_action_cache_gc_max_age"><a href="#common_options-flag--experimental_action_cache_gc_max_age">--experimental_action_cache_gc_max_age</a>=&lt;An immutable length of time.&gt;</code> default: "0"</dt>
<dd>
<p>If set to a nonzero value, the action cache will be periodically garbage collected to remove entries older than this age. Garbage collection occurs in the background once the server has become idle, as determined by the --experimental_action_cache_gc_idle_delay and --experimental_action_cache_gc_threshold flags.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="common_options-flag--experimental_action_cache_gc_threshold"><code id="experimental_action_cache_gc_threshold"><a href="#common_options-flag--experimental_action_cache_gc_threshold">--experimental_action_cache_gc_threshold</a>=&lt;an integer in 0-100 range&gt;</code> default: "10"</dt>
<dd>
<p>The percentage of stale action cache entries required for garbage collection to be triggered. Ineffectual unless --experimental_action_cache_gc_max_age is nonzero.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="common_options-flag--experimental_disk_cache_gc_idle_delay"><code id="experimental_disk_cache_gc_idle_delay"><a href="#common_options-flag--experimental_disk_cache_gc_idle_delay">--experimental_disk_cache_gc_idle_delay</a>=&lt;An immutable length of time.&gt;</code> default: "5m"</dt>
<dd>
<p>How long the server must remain idle before a garbage collection of the disk cache occurs. To specify the garbage collection policy, set --experimental_disk_cache_gc_max_size and/or --experimental_disk_cache_gc_max_age.</p>
</dd>
<dt id="common_options-flag--experimental_disk_cache_gc_max_age"><code id="experimental_disk_cache_gc_max_age"><a href="#common_options-flag--experimental_disk_cache_gc_max_age">--experimental_disk_cache_gc_max_age</a>=&lt;An immutable length of time.&gt;</code> default: "0"</dt>
<dd>
<p>If set to a positive value, the disk cache will be periodically garbage collected to remove entries older than this age. If set in conjunction with --experimental_disk_cache_gc_max_size, both criteria are applied. Garbage collection occurrs in the background once the server has become idle, as determined by the --experimental_disk_cache_gc_idle_delay flag.</p>
</dd>
<dt id="common_options-flag--experimental_disk_cache_gc_max_size"><code id="experimental_disk_cache_gc_max_size"><a href="#common_options-flag--experimental_disk_cache_gc_max_size">--experimental_disk_cache_gc_max_size</a>=&lt;a size in bytes, optionally followed by a K, M, G or T multiplier&gt;</code> default: "0"</dt>
<dd>
<p>If set to a positive value, the disk cache will be periodically garbage collected to stay under this size. If set in conjunction with --experimental_disk_cache_gc_max_age, both criteria are applied. Garbage collection occurrs in the background once the server has become idle, as determined by the --experimental_disk_cache_gc_idle_delay flag.</p>
</dd>
<dt id="common_options-flag--experimental_enable_thread_dump"><code id="experimental_enable_thread_dump"><a href="#common_options-flag--experimental_enable_thread_dump">--[no]experimental_enable_thread_dump</a></code> default: "false"</dt>
<dd>
<p>Whether to enable thread dumps. If true, Bazel will dump the state of all threads (including virtual threads) to a file every --experimental_thread_dump_interval, or after action execution being inactive for --experimental_thread_dump_action_execution_inactivity_duration. The dumps will be written to the &lt;output_base&gt;/server/thread_dumps/ directory.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--experimental_install_base_gc_max_age"><code id="experimental_install_base_gc_max_age"><a href="#common_options-flag--experimental_install_base_gc_max_age">--experimental_install_base_gc_max_age</a>=&lt;An immutable length of time.&gt;</code> default: "30d"</dt>
<dd>
<p>How long an install base must go unused before it's eligible for garbage collection. If nonzero, the server will attempt to garbage collect other install bases when idle.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="common_options-flag--experimental_rule_extension_api"><code id="experimental_rule_extension_api"><a href="#common_options-flag--experimental_rule_extension_api">--[no]experimental_rule_extension_api</a></code> default: "true"</dt>
<dd>
<p>Enable experimental rule extension API and subrule APIs</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="common_options-flag--experimental_thread_dump_action_execution_inactivity_duration"><code id="experimental_thread_dump_action_execution_inactivity_duration"><a href="#common_options-flag--experimental_thread_dump_action_execution_inactivity_duration">--experimental_thread_dump_action_execution_inactivity_duration</a>=&lt;An immutable length of time.&gt;</code> default: "0"</dt>
<dd>
<p>Dump the threads when action execution being inactive for this duration. If zero, no thread dumps are written for action execution being inactive.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--experimental_thread_dump_interval"><code id="experimental_thread_dump_interval"><a href="#common_options-flag--experimental_thread_dump_interval">--experimental_thread_dump_interval</a>=&lt;An immutable length of time.&gt;</code> default: "0"</dt>
<dd>
<p>How often to dump the threads periodically. If zero, no thread dumps are written periodically.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="common_options-flag--experimental_windows_watchfs"><code id="experimental_windows_watchfs"><a href="#common_options-flag--experimental_windows_watchfs">--[no]experimental_windows_watchfs</a></code> default: "false"</dt>
<dd>
<p>If true, experimental Windows support for --watchfs is enabled. Otherwise --watchfsis a non-op on Windows. Make sure to also enable --watchfs.</p>
</dd>
<dt id="common_options-flag--google_auth_scopes"><code id="google_auth_scopes"><a href="#common_options-flag--google_auth_scopes">--google_auth_scopes</a>=&lt;comma-separated list of options&gt;</code> default: "https://www.googleapis.com/auth/cloud-platform"</dt>
<dd>
<p>A comma-separated list of Google Cloud authentication scopes.</p>
</dd>
<dt id="common_options-flag--google_credentials"><code id="google_credentials"><a href="#common_options-flag--google_credentials">--google_credentials</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specifies the file to get authentication credentials from. See https://cloud.google.com/docs/authentication for details.</p>
</dd>
<dt id="common_options-flag--google_default_credentials"><code id="google_default_credentials"><a href="#common_options-flag--google_default_credentials">--[no]google_default_credentials</a></code> default: "false"</dt>
<dd>
<p>Whether to use 'Google Application Default Credentials' for authentication.
See <a href="https://cloud.google.com/docs/authentication">Authentication methods at Google - Google Cloud</a> for details.
Disabled by default.</p>
</dd>
<dt id="common_options-flag--grpc_keepalive_time"><code id="grpc_keepalive_time"><a href="#common_options-flag--grpc_keepalive_time">--grpc_keepalive_time</a>=&lt;An immutable length of time.&gt;</code> default: see description</dt>
<dd>
<p>Configures keep-alive pings for outgoing gRPC connections. If this is set, then Bazel
sends pings after this much time of no read operations on the connection, but
only if there is at least one pending gRPC call. Times are treated as second
granularity; it is an error to set a value less than one second. By default,
keep-alive pings are disabled. You should coordinate with the service owner
before enabling this setting. For example to set a value of 30 seconds to this
flag, it should be done as this <code>--grpc_keepalive_time=30s</code>.</p>
</dd>
<dt id="common_options-flag--grpc_keepalive_timeout"><code id="grpc_keepalive_timeout"><a href="#common_options-flag--grpc_keepalive_timeout">--grpc_keepalive_timeout</a>=&lt;An immutable length of time.&gt;</code> default: "20s"</dt>
<dd>
<p>Configures a keep-alive timeout for outgoing gRPC connections. If keep-alive pings are
enabled with <code>--grpc_keepalive_time</code>, then Bazel times out a connection if it does
not receive a ping reply after this much time. Times are treated as second
granularity; it is an error to set a value less than one second. If keep-alive
pings are disabled, then this setting is ignored.</p>
</dd>
<dt id="common_options-flag--incompatible_disable_non_executable_java_binary"><code id="incompatible_disable_non_executable_java_binary"><a href="#common_options-flag--incompatible_disable_non_executable_java_binary">--[no]incompatible_disable_non_executable_java_binary</a></code> default: "false"</dt>
<dd>
<p>If true, java_binary is always executable. create_executable attribute is removed.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--incompatible_repo_env_ignores_action_env"><code id="incompatible_repo_env_ignores_action_env"><a href="#common_options-flag--incompatible_repo_env_ignores_action_env">--[no]incompatible_repo_env_ignores_action_env</a></code> default: "true"</dt>
<dd>
<p>If true, &lt;code&gt;--action_env=NAME=VALUE&lt;/code&gt; will no longer affect repository rule and module extension environments.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="common_options-flag--inject_repository"><code id="inject_repository"><a href="#common_options-flag--inject_repository">--inject_repository</a>=&lt;an equals-separated mapping of repository name to path&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Adds a new repository with a local path in the form of <code>{repository name}={path}</code>. This
only takes effect with <code>--enable_bzlmod</code> and is equivalent to adding a
corresponding <code>local_repository</code> to the root module's <code>MODULE.bazel</code> file via
<code>use_repo_rule</code>. If the given path is an absolute path, it will be used as it is.
If the given path is a relative path, it is relative to the current working
directory. If the given path starts with <code>%workspace%</code>, it is relative to the
workspace root, which is the output of <code>bazel info workspace</code>. If the given path
is empty, then remove any previous injections.</p>
</dd>
<dt id="common_options-flag--invocation_id"><code id="invocation_id"><a href="#common_options-flag--invocation_id">--invocation_id</a>=&lt;a UUID&gt;</code> default: ""</dt>
<dd>
<p>Unique identifier, in UUID format, for the command being run. If explicitly specified uniqueness must be ensured by the caller. The UUID is printed to stderr, the BEP and remote execution protocol.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>, <a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="common_options-flag--override_repository"><code id="override_repository"><a href="#common_options-flag--override_repository">--override_repository</a>=&lt;an equals-separated mapping of repository name to path&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Override a repository with a local path in the form of <code>{repository name}={path}</code>. If the
given path is an absolute path, it will be used as it is. If the given path is a
relative path, it is relative to the current working directory. If the given path
starts with <code>%workspace%</code>, it is relative to the workspace root, which is the
output of <code>bazel info workspace</code>. If the given path is empty, then remove any
previous overrides.</p>
</dd>
<dt id="common_options-flag--progress_in_terminal_title"><code id="progress_in_terminal_title"><a href="#common_options-flag--progress_in_terminal_title">--[no]progress_in_terminal_title</a></code> default: "false"</dt>
<dd>
<p>Show the command progress in the terminal title. Useful to see what bazel is doing when having multiple terminal tabs.</p>
</dd>
<dt id="common_options-flag--show_progress"><code id="show_progress"><a href="#common_options-flag--show_progress">--[no]show_progress</a></code> default: "true"</dt>
<dd>
<p>Display progress messages during a build.</p>
</dd>
<dt id="common_options-flag--show_progress_rate_limit"><code id="show_progress_rate_limit"><a href="#common_options-flag--show_progress_rate_limit">--show_progress_rate_limit</a>=&lt;a double&gt;</code> default: "0.2"</dt>
<dd>
<p>Minimum number of seconds between progress messages in the output.</p>
</dd>
<dt id="common_options-flag--show_timestamps"><code id="show_timestamps"><a href="#common_options-flag--show_timestamps">--[no]show_timestamps</a></code> default: "false"</dt>
<dd>
<p>Include timestamps in messages</p>
</dd>
<dt id="common_options-flag--tls_certificate"><code id="tls_certificate"><a href="#common_options-flag--tls_certificate">--tls_certificate</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specify a path to a TLS certificate that is trusted to sign server certificates.</p>
</dd>
<dt id="common_options-flag--tls_client_certificate"><code id="tls_client_certificate"><a href="#common_options-flag--tls_client_certificate">--tls_client_certificate</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specify the TLS client certificate to use; you also need to provide a client key to enable client authentication.</p>
</dd>
<dt id="common_options-flag--tls_client_key"><code id="tls_client_key"><a href="#common_options-flag--tls_client_key">--tls_client_key</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specify the TLS client key to use; you also need to provide a client certificate to enable client authentication.</p>
</dd>
<dt id="common_options-flag--ui_actions_shown"><code id="ui_actions_shown"><a href="#common_options-flag--ui_actions_shown">--ui_actions_shown</a>=&lt;an integer&gt;</code> default: "8"</dt>
<dd>
<p>Number of concurrent actions shown in the detailed progress bar; each action is shown on a separate line. The progress bar always shows at least one one, all numbers less than 1 are mapped to 1.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="common_options-flag--watchfs"><code id="watchfs"><a href="#common_options-flag--watchfs">--[no]watchfs</a></code> default: "false"</dt>
<dd>
<p>On Linux/macOS: If true, bazel tries to use the operating system's file watch service for local changes instead of scanning every file for a change. On Windows: this flag currently is a non-op but can be enabled in conjunction with --experimental_windows_watchfs. On any OS: The behavior is undefined if your workspace is on a network file system, and files are edited on a remote machine.</p>
</dd>
</dl>

<h2><a name="aquery">Aquery Options</a></h2>
<p>Inherits all options from <a href="#build">build</a>.</p>

<dl>Options relating to query output and semantics:
<dt id="aquery-flag--aspect_deps"><code id="aspect_deps"><a href="#aquery-flag--aspect_deps">--aspect_deps</a>=&lt;off, conservative or precise&gt;</code> default: "conservative"</dt>
<dd>
<p>How to resolve aspect dependencies when the output format is one of {xml,proto,record}. 'off' means no aspect dependencies are resolved, 'conservative' (the default) means all declared aspect dependencies are added regardless of whether they are given the rule class of direct dependencies, 'precise' means that only those aspects are added that are possibly active given the rule class of the direct dependencies. Note that precise mode requires loading other packages to evaluate a single target thus making it slower than the other modes. Also note that even precise mode is not completely precise: the decision whether to compute an aspect is decided in the analysis phase, which is not run during 'bazel query'.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="aquery-flag--consistent_labels"><code id="consistent_labels"><a href="#aquery-flag--consistent_labels">--[no]consistent_labels</a></code> default: "false"</dt>
<dd>
<p>If enabled, every query command emits labels as if by the Starlark &lt;code&gt;str&lt;/code&gt; function applied to a &lt;code&gt;Label&lt;/code&gt; instance. This is useful for tools that need to match the output of different query commands and/or labels emitted by rules. If not enabled, output formatters are free to emit apparent repository names (relative to the main repository) instead to make the output more readable.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--experimental_explicit_aspects"><code id="experimental_explicit_aspects"><a href="#aquery-flag--experimental_explicit_aspects">--[no]experimental_explicit_aspects</a></code> default: "false"</dt>
<dd>
<p>aquery, cquery: whether to include aspect-generated actions in the output. query: no-op (aspects are always followed).</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--graph:factored"><code id="graph:factored"><a href="#aquery-flag--graph:factored">--[no]graph:factored</a></code> default: "true"</dt>
<dd>
<p>If true, then the graph will be emitted 'factored', i.e. topologically-equivalent nodes will be merged together and their labels concatenated. This option is only applicable to --output=graph.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--graph:node_limit"><code id="graph:node_limit"><a href="#aquery-flag--graph:node_limit">--graph:node_limit</a>=&lt;an integer&gt;</code> default: "512"</dt>
<dd>
<p>The maximum length of the label string for a graph node in the output.  Longer labels will be truncated; -1 means no truncation.  This option is only applicable to --output=graph.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--implicit_deps"><code id="implicit_deps"><a href="#aquery-flag--implicit_deps">--[no]implicit_deps</a></code> default: "true"</dt>
<dd>
<p>If enabled, implicit dependencies will be included in the dependency graph over which the query operates. An implicit dependency is one that is not explicitly specified in the BUILD file but added by bazel. For cquery, this option controls filtering resolved toolchains.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="aquery-flag--include_artifacts"><code id="include_artifacts"><a href="#aquery-flag--include_artifacts">--[no]include_artifacts</a></code> default: "true"</dt>
<dd>
<p>Includes names of the action inputs and outputs in the output (potentially large).</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--include_aspects"><code id="include_aspects"><a href="#aquery-flag--include_aspects">--[no]include_aspects</a></code> default: "true"</dt>
<dd>
<p>aquery, cquery: whether to include aspect-generated actions in the output. query: no-op (aspects are always followed).</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--include_commandline"><code id="include_commandline"><a href="#aquery-flag--include_commandline">--[no]include_commandline</a></code> default: "true"</dt>
<dd>
<p>Includes the content of the action command lines in the output (potentially large).</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--include_file_write_contents"><code id="include_file_write_contents"><a href="#aquery-flag--include_file_write_contents">--[no]include_file_write_contents</a></code> default: "false"</dt>
<dd>
<p>Include the file contents for the FileWrite, SourceSymlinkManifest, and RepoMappingManifest actions (potentially large).</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--include_param_files"><code id="include_param_files"><a href="#aquery-flag--include_param_files">--[no]include_param_files</a></code> default: "false"</dt>
<dd>
<p>Include the content of the param files used in the command (potentially large). Note: Enabling this flag will automatically enable the --include_commandline flag.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--include_pruned_inputs"><code id="include_pruned_inputs"><a href="#aquery-flag--include_pruned_inputs">--[no]include_pruned_inputs</a></code> default: "true"</dt>
<dd>
<p>Includes action inputs that were pruned during action execution. Only affects actions that discover inputs and have been executed in a previous invocation. Only takes effect if --include_artifacts is also set.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--incompatible_package_group_includes_double_slash"><code id="incompatible_package_group_includes_double_slash"><a href="#aquery-flag--incompatible_package_group_includes_double_slash">--[no]incompatible_package_group_includes_double_slash</a></code> default: "true"</dt>
<dd>
<p>If enabled, when outputting package_group's <code>packages</code> attribute, the leading <code>//</code> will not be omitted.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="aquery-flag--infer_universe_scope"><code id="infer_universe_scope"><a href="#aquery-flag--infer_universe_scope">--[no]infer_universe_scope</a></code> default: "false"</dt>
<dd>
<p>If set and --universe_scope is unset, then a value of --universe_scope will be inferred as the list of unique target patterns in the query expression. Note that the --universe_scope value inferred for a query expression that uses universe-scoped functions (e.g.<code>allrdeps</code>) may not be what you want, so you should use this option only if you know what you are doing. See https://bazel.build/reference/query#sky-query for details and examples. If --universe_scope is set, then this option's value is ignored. Note: this option applies only to <code>query</code> (i.e. not <code>cquery</code>).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="aquery-flag--line_terminator_null"><code id="line_terminator_null"><a href="#aquery-flag--line_terminator_null">--[no]line_terminator_null</a></code> default: "false"</dt>
<dd>
<p>Whether each format is terminated with \0 instead of newline.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--nodep_deps"><code id="nodep_deps"><a href="#aquery-flag--nodep_deps">--[no]nodep_deps</a></code> default: "true"</dt>
<dd>
<p>If enabled, deps from &quot;nodep&quot; attributes will be included in the dependency graph over which the query operates. A common example of a &quot;nodep&quot; attribute is &quot;visibility&quot;. Run and parse the output of <code>info build-language</code> to learn about all the &quot;nodep&quot; attributes in the build language.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="aquery-flag--output"><code id="output"><a href="#aquery-flag--output">--output</a>=&lt;a string&gt;</code> default: "text"</dt>
<dd>
<p>The format in which the aquery results should be printed. Allowed values for aquery are: text, textproto, proto, streamed_proto, jsonproto.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--output_file"><code id="output_file"><a href="#aquery-flag--output_file">--output_file</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>When specified, query results will be written directly to this file, and nothing will be printed to Bazel's standard output stream (stdout). In benchmarks, this is generally faster than &lt;code&gt;bazel query &amp;gt; file&lt;/code&gt;.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--proto:default_values"><code id="proto:default_values"><a href="#aquery-flag--proto:default_values">--[no]proto:default_values</a></code> default: "true"</dt>
<dd>
<p>If true, attributes whose value is not explicitly specified in the BUILD file are included; otherwise they are omitted. This option is applicable to --output=proto</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--proto:definition_stack"><code id="proto:definition_stack"><a href="#aquery-flag--proto:definition_stack">--[no]proto:definition_stack</a></code> default: "false"</dt>
<dd>
<p>Populate the definition_stack proto field, which records for each rule instance the Starlark call stack at the moment the rule's class was defined.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--proto:flatten_selects"><code id="proto:flatten_selects"><a href="#aquery-flag--proto:flatten_selects">--[no]proto:flatten_selects</a></code> default: "true"</dt>
<dd>
<p>If enabled, configurable attributes created by select() are flattened. For list types the flattened representation is a list containing each value of the select map exactly once. Scalar types are flattened to null.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="aquery-flag--proto:include_attribute_source_aspects"><code id="proto:include_attribute_source_aspects"><a href="#aquery-flag--proto:include_attribute_source_aspects">--[no]proto:include_attribute_source_aspects</a></code> default: "false"</dt>
<dd>
<p>Populate the source_aspect_name proto field of each Attribute with the source aspect that the attribute came from (empty string if it did not).</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--proto:include_starlark_rule_env"><code id="proto:include_starlark_rule_env"><a href="#aquery-flag--proto:include_starlark_rule_env">--[no]proto:include_starlark_rule_env</a></code> default: "true"</dt>
<dd>
<p>Use the starlark environment in the value of the generated $internal_attr_hash attribute. This ensures that the starlark rule definition (and its transitive imports) are part of this identifier.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--proto:include_synthetic_attribute_hash"><code id="proto:include_synthetic_attribute_hash"><a href="#aquery-flag--proto:include_synthetic_attribute_hash">--[no]proto:include_synthetic_attribute_hash</a></code> default: "false"</dt>
<dd>
<p>Whether or not to calculate and populate the $internal_attr_hash attribute.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--proto:instantiation_stack"><code id="proto:instantiation_stack"><a href="#aquery-flag--proto:instantiation_stack">--[no]proto:instantiation_stack</a></code> default: "false"</dt>
<dd>
<p>Populate the instantiation call stack of each rule. Note that this requires the stack to be present</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--proto:locations"><code id="proto:locations"><a href="#aquery-flag--proto:locations">--[no]proto:locations</a></code> default: "true"</dt>
<dd>
<p>Whether to output location information in proto output at all.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--proto:output_rule_attrs"><code id="proto:output_rule_attrs"><a href="#aquery-flag--proto:output_rule_attrs">--proto:output_rule_attrs</a>=&lt;comma-separated list of options&gt;</code> default: "all"</dt>
<dd>
<p>Comma separated list of attributes to include in output. Defaults to all attributes. Set to empty string to not output any attribute. This option is applicable to --output=proto.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--proto:rule_classes"><code id="proto:rule_classes"><a href="#aquery-flag--proto:rule_classes">--[no]proto:rule_classes</a></code> default: "false"</dt>
<dd>
<p>Populate the rule_class_key field of each rule; and for the first rule with a given rule_class_key, also populate its rule_class_info proto field. The rule_class_key field uniquely identifies a rule class, and the rule_class_info field is a Stardoc-format rule class API definition.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--proto:rule_inputs_and_outputs"><code id="proto:rule_inputs_and_outputs"><a href="#aquery-flag--proto:rule_inputs_and_outputs">--[no]proto:rule_inputs_and_outputs</a></code> default: "true"</dt>
<dd>
<p>Whether or not to populate the rule_input and rule_output fields.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--query_file"><code id="query_file"><a href="#aquery-flag--query_file">--query_file</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>If set, query will read the query from the file named here, rather than on the command line. It is an error to specify a file here as well as a command-line query.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="aquery-flag--relative_locations"><code id="relative_locations"><a href="#aquery-flag--relative_locations">--[no]relative_locations</a></code> default: "false"</dt>
<dd>
<p>If true, the location of BUILD files in xml and proto outputs will be relative. By default, the location output is an absolute path and will not be consistent across machines. You can set this option to true to have a consistent result across machines.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--skyframe_state"><code id="skyframe_state"><a href="#aquery-flag--skyframe_state">--[no]skyframe_state</a></code> default: "false"</dt>
<dd>
<p>Without performing extra analysis, dump the current Action Graph from Skyframe. Note: Specifying a target with --skyframe_state is currently not supported. This flag is only available with --output=proto or --output=textproto.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="aquery-flag--tool_deps"><code id="tool_deps"><a href="#aquery-flag--tool_deps">--[no]tool_deps</a></code> default: "true"</dt>
<dd>
<p>Query: If disabled, dependencies on 'exec configuration' will not be included in the dependency graph over which the query operates. An 'exec configuration' dependency edge, such as the one from any 'proto_library' rule to the Protocol Compiler, usually points to a tool executed during the build rather than a part of the same 'target' program.
Cquery: If disabled, filters out all configured targets which cross an execution transition from the top-level target that discovered this configured target. That means if the top-level target is in the target configuration, only configured targets also in the target configuration will be returned. If the top-level target is in the exec configuration, only exec configured targets will be returned. This option will NOT exclude resolved toolchains.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="aquery-flag--universe_scope"><code id="universe_scope"><a href="#aquery-flag--universe_scope">--universe_scope</a>=&lt;comma-separated list of options&gt;</code> default: ""</dt>
<dd>
<p>A comma-separated set of target patterns (additive and subtractive). The query may be performed in the universe defined by the transitive closure of the specified targets. This option is used for the query and cquery commands.
For cquery, the input to this option is the targets all answers are built under and so this option may affect configurations and transitions. If this option is not specified, the top-level targets are assumed to be the targets parsed from the query expression. Note: For cquery, not specifying this option may cause the build to break if targets parsed from the query expression are not buildable with top-level options.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
</dl>

<dl>Options that control build execution:
<dt id="flag--experimental_persistent_aar_extractor"><code><a href="#flag--experimental_persistent_aar_extractor">--[no]experimental_persistent_aar_extractor</a></code> default: "false"</dt>
<dd>
<p>Enable persistent aar extractor by using workers.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_remotable_source_manifests"><code><a href="#flag--experimental_remotable_source_manifests">--[no]experimental_remotable_source_manifests</a></code> default: "false"</dt>
<dd>
<p>Whether to make source manifest actions remotable</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_split_coverage_postprocessing"><code><a href="#flag--experimental_split_coverage_postprocessing">--[no]experimental_split_coverage_postprocessing</a></code> default: "false"</dt>
<dd>
<p>If true, then Bazel will run coverage postprocessing for test in a new spawn.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_strict_fileset_output"><code><a href="#flag--experimental_strict_fileset_output">--[no]experimental_strict_fileset_output</a></code> default: "false"</dt>
<dd>
<p>If this option is enabled, filesets will treat all output artifacts as regular files. They will not traverse directories or be sensitive to symlinks.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--incompatible_modify_execution_info_additive"><code><a href="#flag--incompatible_modify_execution_info_additive">--[no]incompatible_modify_execution_info_additive</a></code> default: "true"</dt>
<dd>
<p>When enabled, passing multiple <code>--modify_execution_info</code> flags is additive.
When disabled, only the last flag is taken into account.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--modify_execution_info"><code><a href="#flag--modify_execution_info">--modify_execution_info</a>=&lt;regex=[+-]key,regex=[+-]key,...&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Add or remove keys from an action's execution info based on action mnemonic.
Applies only to actions which support execution info. Many common actions
support execution info, e.g. Genrule, CppCompile, Javac, StarlarkAction,
TestRunner. When specifying multiple values, order matters because
many regexes may apply to the same mnemonic.</p>
<p>Syntax: <code>regex=[+-]key,regex=[+-]key,...</code>.</p>
<p>Examples:</p>
<ul>
<li><code>.*=+x,.*=-y,.*=+z</code> adds <code>x</code> and <code>z</code> to, and removes <code>y</code> from, the execution info for all actions.</li>
<li><code>Genrule=+requires-x</code> adds <code>requires-x</code> to the execution info for all Genrule actions.</li>
<li><code>(?!Genrule).*=-requires-x</code> removes <code>requires-x</code> from the execution info for all non-Genrule actions.</li>
</ul>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--persistent_android_dex_desugar"><code><a href="#flag--persistent_android_dex_desugar">--persistent_android_dex_desugar</a></code></dt>
<dd>
<p>Enable persistent Android dex and desugar actions by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_android_dex_desugar">--internal_persistent_android_dex_desugar</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=Desugar=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=DexBuilder=worker</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_android_resource_processor"><code><a href="#flag--persistent_android_resource_processor">--persistent_android_resource_processor</a></code></dt>
<dd>
<p>Enable persistent Android resource processor by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_busybox_tools">--internal_persistent_busybox_tools</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AaptPackage=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceParser=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceValidator=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceCompiler=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=RClassGenerator=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceLink=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidAapt2=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidAssetMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidCompiledResourceMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=ManifestMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidManifestMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=Aapt2Optimize=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AARGenerator=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=ProcessDatabinding=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=GenerateDataBindingBaseClasses=worker</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_multiplex_android_dex_desugar"><code><a href="#flag--persistent_multiplex_android_dex_desugar">--persistent_multiplex_android_dex_desugar</a></code></dt>
<dd>
<p>Enable persistent multiplexed Android dex and desugar actions by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_android_dex_desugar">--persistent_android_dex_desugar</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_multiplex_android_dex_desugar">--internal_persistent_multiplex_android_dex_desugar</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_multiplex_android_resource_processor"><code><a href="#flag--persistent_multiplex_android_resource_processor">--persistent_multiplex_android_resource_processor</a></code></dt>
<dd>
<p>Enable persistent multiplexed Android resource processor by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_android_resource_processor">--persistent_android_resource_processor</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AaptPackage=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceParser=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceValidator=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceCompiler=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=RClassGenerator=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceLink=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidAapt2=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidAssetMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidCompiledResourceMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=ManifestMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidManifestMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=Aapt2Optimize=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AARGenerator=+supports-multiplex-workers</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_multiplex_android_tools"><code><a href="#flag--persistent_multiplex_android_tools">--persistent_multiplex_android_tools</a></code></dt>
<dd>
<p>Enable persistent and multiplexed Android tools (dexing, desugaring, resource processing).</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_multiplex_busybox_tools">--internal_persistent_multiplex_busybox_tools</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_multiplex_android_resource_processor">--persistent_multiplex_android_resource_processor</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_multiplex_android_dex_desugar">--persistent_multiplex_android_dex_desugar</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--use_target_platform_for_tests"><code><a href="#flag--use_target_platform_for_tests">--[no]use_target_platform_for_tests</a></code> default: "false"</dt>
<dd>
<p>If true, use the target platform for running tests rather than the test exec group.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
</dl>
<dl>Options that configure the toolchain used for action execution:
<dt id="flag--android_compiler"><code><a href="#flag--android_compiler">--android_compiler</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The Android target compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--android_manifest_merger"><code><a href="#flag--android_manifest_merger">--android_manifest_merger</a>=&lt;legacy, android or force_android&gt;</code> default: "android"</dt>
<dd>
<p>Selects the manifest merger to use for android_binary rules. Flag to help the transition to the Android manifest merger from the legacy merger.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--android_platforms"><code><a href="#flag--android_platforms">--android_platforms</a>=&lt;a build target label&gt;</code> default: ""</dt>
<dd>
<p>Sets the platforms that android_binary targets use. If multiple platforms are specified, then the binary is a fat APKs, which contains native binaries for each specified target platform.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--cc_output_directory_tag"><code><a href="#flag--cc_output_directory_tag">--cc_output_directory_tag</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Specifies a suffix to be added to the configuration directory.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--compiler"><code><a href="#flag--compiler">--compiler</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The C++ compiler to use for compiling the target.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--coverage_output_generator"><code><a href="#flag--coverage_output_generator">--coverage_output_generator</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/test:lcov_merger"</dt>
<dd>
<p>Location of the binary that is used to postprocess raw coverage reports. This must
be a binary target. Defaults to <code>@bazel_tools//tools/test:lcov_merger</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--coverage_report_generator"><code><a href="#flag--coverage_report_generator">--coverage_report_generator</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/test:coverage_report_generator"</dt>
<dd>
<p>Location of the binary that is used to generate coverage reports. This must
be a binary target. Defaults to <code>@bazel_tools//tools/test:coverage_report_generator</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--coverage_support"><code><a href="#flag--coverage_support">--coverage_support</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/test:coverage_support"</dt>
<dd>
<p>Location of support files that are required on the inputs of every test action
that collects code coverage. Defaults to <code>//tools/test:coverage_support</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--custom_malloc"><code><a href="#flag--custom_malloc">--custom_malloc</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies a custom malloc implementation. This setting overrides malloc attributes in build rules.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--experimental_include_xcode_execution_requirements"><code><a href="#flag--experimental_include_xcode_execution_requirements">--[no]experimental_include_xcode_execution_requirements</a></code> default: "false"</dt>
<dd>
<p>If set, add a &quot;requires-xcode:{version}&quot; execution requirement to every Xcode action.  If the Xcode version has a hyphenated label,  also add a &quot;requires-xcode-label:{version_label}&quot; execution requirement.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_prefer_mutual_xcode"><code><a href="#flag--experimental_prefer_mutual_xcode">--[no]experimental_prefer_mutual_xcode</a></code> default: "true"</dt>
<dd>
<p>If true, use the most recent Xcode that is available both locally and remotely. If false, or if there are no mutual available versions, use the local Xcode version selected via xcode-select.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--extra_execution_platforms"><code><a href="#flag--extra_execution_platforms">--extra_execution_platforms</a>=&lt;comma-separated list of options&gt;</code> default: ""</dt>
<dd>
<p>The platforms that are available as execution platforms to run actions.
Platforms can be specified by exact target, or as a target pattern.
These platforms will be considered before those declared in the <code>WORKSPACE</code> file by
<code>register_execution_platforms()</code>. This option may only be set once; later
instances will override earlier flag settings.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--extra_toolchains"><code><a href="#flag--extra_toolchains">--extra_toolchains</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The toolchain rules to be considered during toolchain resolution.
Toolchains can be specified by exact target, or as a target pattern.
These toolchains will be considered before those declared in the <code>WORKSPACE</code> file
by <code>register_toolchains()</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--grte_top"><code><a href="#flag--grte_top">--grte_top</a>=&lt;a label&gt;</code> default: see description</dt>
<dd>
<p>A label to a checked-in libc library. The default value is selected by the crosstool toolchain, and you almost never need to override it.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_compiler"><code><a href="#flag--host_compiler">--host_compiler</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>No-op flag. Will be removed in a future release.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--host_grte_top"><code><a href="#flag--host_grte_top">--host_grte_top</a>=&lt;a label&gt;</code> default: see description</dt>
<dd>
<p>If specified, this setting overrides the libc top-level directory (--grte_top) for the exec configuration.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_platform"><code><a href="#flag--host_platform">--host_platform</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools:host_platform"</dt>
<dd>
<p>The label of a platform rule that describes the host system.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--incompatible_bazel_test_exec_run_under"><code><a href="#flag--incompatible_bazel_test_exec_run_under">--[no]incompatible_bazel_test_exec_run_under</a></code> default: "true"</dt>
<dd>
<p>If enabled, <code>bazel test --run_under=//:runner</code> builds <code>//:runner</code> in the exec
configuration. If disabled, it builds <code>//:runner</code> in the target configuration.
Bazel executes tests on exec machines, so the former is more correct. This
doesn't affect <code>bazel run</code>, which always builds <code>--run_under=//foo</code> in the
target configuration.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_builtin_objc_strip_action"><code><a href="#flag--incompatible_builtin_objc_strip_action">--[no]incompatible_builtin_objc_strip_action</a></code> default: "true"</dt>
<dd>
<p>Whether to emit a strip action as part of objc linking.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_dont_enable_host_nonhost_crosstool_features"><code><a href="#flag--incompatible_dont_enable_host_nonhost_crosstool_features">--[no]incompatible_dont_enable_host_nonhost_crosstool_features</a></code> default: "true"</dt>
<dd>
<p>If true, Bazel will not enable 'host' and 'nonhost' features in the c++ toolchain (see https://github.com/bazelbuild/bazel/issues/7407 for more information).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_enable_apple_toolchain_resolution"><code><a href="#flag--incompatible_enable_apple_toolchain_resolution">--[no]incompatible_enable_apple_toolchain_resolution</a></code> default: "false"</dt>
<dd>
<p>Use toolchain resolution to select the Apple SDK for apple rules (Starlark and native)</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_remove_legacy_whole_archive"><code><a href="#flag--incompatible_remove_legacy_whole_archive">--[no]incompatible_remove_legacy_whole_archive</a></code> default: "true"</dt>
<dd>
<p>If true, Bazel will not link library dependencies as whole archive by default (see https://github.com/bazelbuild/bazel/issues/7362 for migration instructions).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_strip_executable_safely"><code><a href="#flag--incompatible_strip_executable_safely">--[no]incompatible_strip_executable_safely</a></code> default: "false"</dt>
<dd>
<p>If true, strip action for executables will use flag -x, which does not break dynamic symbol resolution.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--interface_shared_objects"><code><a href="#flag--interface_shared_objects">--[no]interface_shared_objects</a></code> default: "true"</dt>
<dd>
<p>Use interface shared objects if supported by the toolchain. All ELF toolchains currently support this setting.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ios_sdk_version"><code><a href="#flag--ios_sdk_version">--ios_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the iOS SDK to use to build iOS applications. If unspecified, uses the default iOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--macos_sdk_version"><code><a href="#flag--macos_sdk_version">--macos_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the macOS SDK to use to build macOS applications. If unspecified, uses the default macOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--minimum_os_version"><code><a href="#flag--minimum_os_version">--minimum_os_version</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The minimum OS version which your compilation targets.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--platform_mappings"><code><a href="#flag--platform_mappings">--platform_mappings</a>=&lt;a main workspace-relative path&gt;</code> default: ""</dt>
<dd>
<p>The location of a mapping file that describes which platform to use if none is set or
which flags to set when a platform already exists. Must be relative to the main
workspace root. Defaults to <code>platform_mappings</code> (a file directly under the
workspace root).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--platforms"><code><a href="#flag--platforms">--platforms</a>=&lt;a build target label&gt;</code> default: ""</dt>
<dd>
<p>The labels of the platform rules describing the target platforms for the current command.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--python_path"><code><a href="#flag--python_path">--python_path</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The absolute path of the Python interpreter invoked to run Python targets on the
target platform. Deprecated; disabled by <code>--incompatible_use_python_toolchains</code>.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--tvos_sdk_version"><code><a href="#flag--tvos_sdk_version">--tvos_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the tvOS SDK to use to build tvOS applications. If unspecified, uses the default tvOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--use_platforms_in_apple_crosstool_transition"><code><a href="#flag--use_platforms_in_apple_crosstool_transition">--[no]use_platforms_in_apple_crosstool_transition</a></code> default: "false"</dt>
<dd>
<p>Makes apple_crosstool_transition fall back to using the value of <code>--platforms</code> flag instead of legacy <code>--cpu</code> when needed.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--watchos_sdk_version"><code><a href="#flag--watchos_sdk_version">--watchos_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the watchOS SDK to use to build watchOS applications. If unspecified, uses the default watchOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--xcode_version"><code><a href="#flag--xcode_version">--xcode_version</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>If specified, uses Xcode of the given version for relevant build actions. If unspecified, uses the executor default version of Xcode.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--xcode_version_config"><code><a href="#flag--xcode_version_config">--xcode_version_config</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/cpp:host_xcodes"</dt>
<dd>
<p>The label of the xcode_config rule to be used for selecting the Xcode version in the build configuration.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
</dl>
<dl>Options that control the output of the command:
<dt id="flag--apple_generate_dsym"><code><a href="#flag--apple_generate_dsym">--[no]apple_generate_dsym</a></code> default: "false"</dt>
<dd>
<p>Whether to generate debug symbol(.dSYM) file(s).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--build_runfile_links"><code><a href="#flag--build_runfile_links">--[no]build_runfile_links</a></code> default: "true"</dt>
<dd>
<p>If true, build runfiles symlink forests for all targets.  If false, write them only when required by a local action, test or run command.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--build_runfile_manifests"><code><a href="#flag--build_runfile_manifests">--[no]build_runfile_manifests</a></code> default: "true"</dt>
<dd>
<p>If true, write runfiles manifests for all targets. If false, omit them. Local tests will fail to run when false.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--build_test_dwp"><code><a href="#flag--build_test_dwp">--[no]build_test_dwp</a></code> default: "false"</dt>
<dd>
<p>If enabled, when building C++ tests statically and with fission the .dwp file  for the test binary will be automatically built as well.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cc_proto_library_header_suffixes"><code><a href="#flag--cc_proto_library_header_suffixes">--cc_proto_library_header_suffixes</a>=&lt;comma-separated set of options&gt;</code> default: ".pb.h"</dt>
<dd>
<p>Sets the suffixes of header files that a cc_proto_library creates.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--cc_proto_library_source_suffixes"><code><a href="#flag--cc_proto_library_source_suffixes">--cc_proto_library_source_suffixes</a>=&lt;comma-separated set of options&gt;</code> default: ".pb.cc"</dt>
<dd>
<p>Sets the suffixes of source files that a cc_proto_library creates.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--experimental_proto_descriptor_sets_include_source_info"><code><a href="#flag--experimental_proto_descriptor_sets_include_source_info">--[no]experimental_proto_descriptor_sets_include_source_info</a></code> default: "false"</dt>
<dd>
<p>Run extra actions for alternative Java api versions in a proto_library.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_save_feature_state"><code><a href="#flag--experimental_save_feature_state">--[no]experimental_save_feature_state</a></code> default: "false"</dt>
<dd>
<p>Save the state of enabled and requested feautres as an output of compilation.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--fission"><code><a href="#flag--fission">--fission</a>=&lt;a set of compilation modes&gt;</code> default: "no"</dt>
<dd>
<p>Specifies which compilation modes use fission for C++ compilations and links.  May be any combination of {'fastbuild', 'dbg', 'opt'} or the special values 'yes'  to enable all modes and 'no' to disable all modes.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--incompatible_always_include_files_in_data"><code><a href="#flag--incompatible_always_include_files_in_data">--[no]incompatible_always_include_files_in_data</a></code> default: "true"</dt>
<dd>
<p>If true, native rules add <code>DefaultInfo.files</code> of data dependencies to their runfiles,
which matches the recommended behavior for Starlark rules (<a href="https://bazel.build/extending/rules#runfiles_features_to_avoid">runfiles features to avoid</a>).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_compact_repo_mapping_manifest"><code><a href="#flag--incompatible_compact_repo_mapping_manifest">--[no]incompatible_compact_repo_mapping_manifest</a></code> default: "false"</dt>
<dd>
<p>If enabled, the <code>{binary}.repo_mapping</code> file emits a module extension's repo mapping
only once instead of once for each repo generated by the extension that
contributes runfiles.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_disable_select_on"><code><a href="#flag--incompatible_disable_select_on">--incompatible_disable_select_on</a>=&lt;comma-separated set of options&gt;</code> default: ""</dt>
<dd>
<p>List of flags for which the use in <code>select()</code> is disabled.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--incompatible_filegroup_runfiles_for_data"><code><a href="#flag--incompatible_filegroup_runfiles_for_data">--[no]incompatible_filegroup_runfiles_for_data</a></code> default: "true"</dt>
<dd>
<p>If true, runfiles of targets listed in the srcs attribute are available to targets that consume the filegroup as a data dependency.</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--objc_generate_linkmap"><code><a href="#flag--objc_generate_linkmap">--[no]objc_generate_linkmap</a></code> default: "false"</dt>
<dd>
<p>Specifies whether to generate a linkmap file.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--save_temps"><code><a href="#flag--save_temps">--[no]save_temps</a></code> default: "false"</dt>
<dd>
<p>If set, temporary outputs from gcc will be saved.  These include .s files (assembler code), .i files (preprocessed C) and .ii files (preprocessed C++).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
</dl>
<dl>Options that let the user configure the intended output, affecting its value, as opposed to its existence:
<dt id="flag--action_env"><code><a href="#flag--action_env">--action_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the set of environment variables available to actions with target
configuration. Variables can be either specified by <code>name</code>, in which case
the value will be taken from the invocation environment, by the <code>name=value</code>
pair which sets the value independent of the invocation environment, or by
<code>=name</code>, which unsets the variable of that name. This option can be used
multiple times; for options given for the same variable, the latest wins,
options for different variables accumulate.</p>
<p>Note that unless <code>--incompatible_repo_env_ignores_action_env</code> is true, all <code>name=value</code>
pairs will be available to repository rules.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--allowed_cpu_values"><code><a href="#flag--allowed_cpu_values">--allowed_cpu_values</a>=&lt;comma-separated set of options&gt;</code> default: ""</dt>
<dd>
<p>Allowed values for the <code>--cpu</code> flag.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--android_databinding_use_androidx"><code><a href="#flag--android_databinding_use_androidx">--[no]android_databinding_use_androidx</a></code> default: "true"</dt>
<dd>
<p>Generate AndroidX-compatible data-binding files. This is only used with databinding v2. This flag is a no-op.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--android_databinding_use_v3_4_args"><code><a href="#flag--android_databinding_use_v3_4_args">--[no]android_databinding_use_v3_4_args</a></code> default: "true"</dt>
<dd>
<p>Use android databinding v2 with 3.4.0 argument. This flag is a no-op.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--android_dynamic_mode"><code><a href="#flag--android_dynamic_mode">--android_dynamic_mode</a>=&lt;off, default or fully&gt;</code> default: "off"</dt>
<dd>
<p>Determines whether C++ deps of Android rules will be linked dynamically when a cc_binary does not explicitly create a shared library. 'default' means bazel will choose whether to link dynamically.  'fully' means all libraries will be linked dynamically. 'off' means that all libraries will be linked in mostly static mode.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--android_manifest_merger_order"><code><a href="#flag--android_manifest_merger_order">--android_manifest_merger_order</a>=&lt;alphabetical, alphabetical_by_configuration or dependency&gt;</code> default: "alphabetical"</dt>
<dd>
<p>Sets the order of manifests passed to the manifest merger for Android binaries. ALPHABETICAL means manifests are sorted by path relative to the execroot. ALPHABETICAL_BY_CONFIGURATION means manifests are sorted by paths relative to the configuration directory within the output directory. DEPENDENCY means manifests are ordered with each library's manifest coming before the manifests of its dependencies.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--android_resource_shrinking"><code><a href="#flag--android_resource_shrinking">--[no]android_resource_shrinking</a></code> default: "false"</dt>
<dd>
<p>Enables resource shrinking for android_binary APKs that use ProGuard.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--build_python_zip"><code><a href="#flag--build_python_zip">--[no]build_python_zip</a></code> default: "auto"</dt>
<dd>
<p>Build python executable zip; on on Windows, off on other platforms</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--catalyst_cpus"><code><a href="#flag--catalyst_cpus">--catalyst_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple Catalyst binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--collect_code_coverage"><code><a href="#flag--collect_code_coverage">--[no]collect_code_coverage</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will instrument code (using offline instrumentation where
possible) and will collect coverage information during tests. Only targets that
match <code>--instrumentation_filter</code> will be affected. Usually this option should
not be specified directly - <code>bazel coverage</code> command should be used instead.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--compilation_mode"><code><a href="#flag--compilation_mode">--compilation_mode</a>=&lt;fastbuild, dbg or opt&gt;</code> [<code>-c</code>] default: "fastbuild"</dt>
<dd>
<p>Specify the mode the binary will be built in. Values: <code>fastbuild</code>, <code>dbg</code>, <code>opt</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--conlyopt"><code><a href="#flag--conlyopt">--conlyopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to gcc when compiling C source files.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--copt"><code><a href="#flag--copt">--copt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to gcc.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cpu"><code><a href="#flag--cpu">--cpu</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Deprecated: this flag is not used internally by Blaze although there are legacy platform
mappings to allow for backwards compatibility. Do not use this flag, instead use
<code>--platforms</code> with an appropriate platform definition.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cs_fdo_absolute_path"><code><a href="#flag--cs_fdo_absolute_path">--cs_fdo_absolute_path</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Use CSFDO profile information to optimize compilation. Specify the absolute path name of the zip file containing the profile file, a raw or an indexed LLVM profile file.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cs_fdo_instrument"><code><a href="#flag--cs_fdo_instrument">--cs_fdo_instrument</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Generate binaries with context sensitive FDO instrumentation. With Clang/LLVM compiler, it also accepts the directory name under which the raw profile file(s) will be dumped at runtime.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cs_fdo_profile"><code><a href="#flag--cs_fdo_profile">--cs_fdo_profile</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The cs_fdo_profile representing the context sensitive profile to be used for optimization.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cxxopt"><code><a href="#flag--cxxopt">--cxxopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to gcc when compiling C++ source files.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--define"><code><a href="#flag--define">--define</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Each <code>--define</code> option specifies an assignment for a build variable.
In case of multiple values for a variable, the last one wins.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--dynamic_mode"><code><a href="#flag--dynamic_mode">--dynamic_mode</a>=&lt;off, default or fully&gt;</code> default: "default"</dt>
<dd>
<p>Determines whether C++ binaries will be linked dynamically.  'default' means Bazel will choose whether to link dynamically.  'fully' means all libraries will be linked dynamically. 'off' means that all libraries will be linked in mostly static mode.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--enable_propeller_optimize_absolute_paths"><code><a href="#flag--enable_propeller_optimize_absolute_paths">--[no]enable_propeller_optimize_absolute_paths</a></code> default: "true"</dt>
<dd>
<p>If set, any use of absolute paths for propeller optimize will raise an error.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--enable_remaining_fdo_absolute_paths"><code><a href="#flag--enable_remaining_fdo_absolute_paths">--[no]enable_remaining_fdo_absolute_paths</a></code> default: "true"</dt>
<dd>
<p>If set, any use of absolute paths for FDO will raise an error.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--enable_runfiles"><code><a href="#flag--enable_runfiles">--[no]enable_runfiles</a></code> default: "auto"</dt>
<dd>
<p>Enable runfiles symlink tree; By default, it's off on Windows, on on other platforms.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--exec_aspects"><code><a href="#flag--exec_aspects">--exec_aspects</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of aspects to be applied to exec-configured targets, regardless of whether or not they are top-level targets. This is an experimental feature and is subject to change.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--experimental_action_listener"><code><a href="#flag--experimental_action_listener">--experimental_action_listener</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Deprecated in favor of aspects. Use <code>action_listener</code> to attach an <code>extra_action</code> to
existing build actions.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_compress_java_resources"><code><a href="#flag--experimental_android_compress_java_resources">--[no]experimental_android_compress_java_resources</a></code> default: "false"</dt>
<dd>
<p>Compress Java resources in APKs</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_databinding_v2"><code><a href="#flag--experimental_android_databinding_v2">--[no]experimental_android_databinding_v2</a></code> default: "true"</dt>
<dd>
<p>Use android databinding v2. This flag is a no-op.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_resource_shrinking"><code><a href="#flag--experimental_android_resource_shrinking">--[no]experimental_android_resource_shrinking</a></code> default: "false"</dt>
<dd>
<p>Enables resource shrinking for android_binary APKs that use ProGuard.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_rewrite_dexes_with_rex"><code><a href="#flag--experimental_android_rewrite_dexes_with_rex">--[no]experimental_android_rewrite_dexes_with_rex</a></code> default: "false"</dt>
<dd>
<p>use rex tool to rewrite dex files</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_collect_code_coverage_for_generated_files"><code><a href="#flag--experimental_collect_code_coverage_for_generated_files">--[no]experimental_collect_code_coverage_for_generated_files</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will also generate collect coverage information for generated files.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_objc_fastbuild_options"><code><a href="#flag--experimental_objc_fastbuild_options">--experimental_objc_fastbuild_options</a>=&lt;comma-separated list of options&gt;</code> default: "-O0,-DDEBUG=1"</dt>
<dd>
<p>Uses these strings as objc fastbuild compiler options.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--experimental_omitfp"><code><a href="#flag--experimental_omitfp">--[no]experimental_omitfp</a></code> default: "false"</dt>
<dd>
<p>If true, use libunwind for stack unwinding, and compile with -fomit-frame-pointer and -fasynchronous-unwind-tables.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_output_paths"><code><a href="#flag--experimental_output_paths">--experimental_output_paths</a>=&lt;off or strip&gt;</code> default: "off"</dt>
<dd>
<p>Which model to use for where in the output tree rules write their outputs, particularly
for multi-platform / multi-configuration builds. This is highly experimental. See
<a href="https://github.com/bazelbuild/bazel/issues/6526">GH-6526</a> for details. Starlark actions can opt into path mapping by adding the key
<code>supports-path-mapping</code> to the <code>execution_requirements</code> dict.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--experimental_override_platform_cpu_name"><code><a href="#flag--experimental_override_platform_cpu_name">--experimental_override_platform_cpu_name</a>=&lt;a &#39;label=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Each entry should be of the form <code>label=value</code> where label refers to a platform and values
is the desired shortname to override the platform's CPU name in <code>$(TARGET_CPU)</code>
make variable and output path. Only used when
<code>--experimental_platform_in_output_dir</code>, <code>--incompatible_target_cpu_from_platform</code> or
<code>--incompatible_bep_cpu_from_platform</code> is true. Has highest naming priority.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_platform_in_output_dir"><code><a href="#flag--experimental_platform_in_output_dir">--[no]experimental_platform_in_output_dir</a></code> default: "Auto"</dt>
<dd>
<p>If true, a shortname for the target platform is used in the output directory name
instead of the CPU. The exact scheme is experimental and subject to change:</p>
<ol>
<li>First, in the rare case the <code>--platforms</code> option does not have exactly one value, a
hash of the platforms option is used.</li>
<li>Next, if any shortname for the current platform was registered by
<code>--experimental_override_name_platform_in_output_dir</code>, then that shortname is used.</li>
<li>Then, if <code>--experimental_use_platforms_in_output_dir_legacy_heuristic</code> is set, use a
shortname based off the current platform Label.</li>
<li>Finally, a hash of the platform option is used as a last resort.</li>
</ol>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_py_binaries_include_label"><code><a href="#flag--experimental_py_binaries_include_label">--[no]experimental_py_binaries_include_label</a></code> default: "false"</dt>
<dd>
<p>py_binary targets include their label even when stamping is disabled.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_use_llvm_covmap"><code><a href="#flag--experimental_use_llvm_covmap">--[no]experimental_use_llvm_covmap</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will generate llvm-cov coverage map information rather than gcov when collect_code_coverage is enabled.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_use_platforms_in_output_dir_legacy_heuristic"><code><a href="#flag--experimental_use_platforms_in_output_dir_legacy_heuristic">--[no]experimental_use_platforms_in_output_dir_legacy_heuristic</a></code> default: "true"</dt>
<dd>
<p>Please only use this flag as part of a suggested migration or testing strategy. Note
that the heuristic has known deficiencies and it is suggested to migrate to
relying on just <code>--experimental_override_name_platform_in_output_dir</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--fdo_instrument"><code><a href="#flag--fdo_instrument">--fdo_instrument</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Generate binaries with FDO instrumentation. With Clang/LLVM compiler, it also accepts the directory name under which the raw profile file(s) will be dumped at runtime.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--fdo_optimize"><code><a href="#flag--fdo_optimize">--fdo_optimize</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Use FDO profile information to optimize compilation. Specify the name of a zip file containing a .gcda file tree, an afdo file containing an auto profile, or an LLVM profile file. This flag also accepts files specified as labels (e.g. <code>//foo/bar:file.afdo</code> - you may need to add an <code>exports_files</code> directive to the corresponding package) and labels pointing to <code>fdo_profile</code> targets. This flag will be superseded by the <code>fdo_profile</code> rule.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--fdo_prefetch_hints"><code><a href="#flag--fdo_prefetch_hints">--fdo_prefetch_hints</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use cache prefetch hints.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--fdo_profile"><code><a href="#flag--fdo_profile">--fdo_profile</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The fdo_profile representing the profile to be used for optimization.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--features"><code><a href="#flag--features">--features</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The given features will be enabled or disabled by default for targets built in the target configuration.
Specifying <code>-{feature}</code> will disable the feature. Negative features always override positive ones.
See also <code>--host_features</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--force_pic"><code><a href="#flag--force_pic">--[no]force_pic</a></code> default: "false"</dt>
<dd>
<p>If enabled, all C++ compilations produce position-independent code (&quot;-fPIC&quot;), links prefer PIC pre-built libraries over non-PIC libraries, and links produce position-independent executables (&quot;-pie&quot;).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_action_env"><code><a href="#flag--host_action_env">--host_action_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the set of environment variables available to actions with execution
configurations. Variables can be either specified by <code>name</code>, in which case the
value will be taken from the invocation environment, by the <code>name=value</code> pair
which sets the value independent of the invocation environment, or by
<code>=name</code>, which unsets the variable of that name. This option can
be used multiple times; for options given for the same variable, the latest
wins, options for different variables accumulate.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--host_compilation_mode"><code><a href="#flag--host_compilation_mode">--host_compilation_mode</a>=&lt;fastbuild, dbg or opt&gt;</code> default: "opt"</dt>
<dd>
<p>Specify the mode the tools used during the build will be built in. Values:
<code>fastbuild</code>, <code>dbg</code>, <code>opt</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--host_conlyopt"><code><a href="#flag--host_conlyopt">--host_conlyopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to the C compiler when compiling C (but not C++) source files in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_copt"><code><a href="#flag--host_copt">--host_copt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the C compiler for tools built in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_cpu"><code><a href="#flag--host_cpu">--host_cpu</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The host CPU.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_cxxopt"><code><a href="#flag--host_cxxopt">--host_cxxopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to C++ compiler for tools built in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_features"><code><a href="#flag--host_features">--host_features</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The given features will be enabled or disabled by default for targets built in the exec configuration.
Specifying <code>-{feature}</code> will disable the feature. Negative features always override positive ones.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_linkopt"><code><a href="#flag--host_linkopt">--host_linkopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to linker when linking tools in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_macos_minimum_os"><code><a href="#flag--host_macos_minimum_os">--host_macos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible macOS version for host targets. If unspecified, uses 'macos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--host_per_file_copt"><code><a href="#flag--host_per_file_copt">--host_per_file_copt</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths followed by an @ and a comma separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to selectively pass to the C/C++ compiler when compiling certain files in the exec configurations. This option can be passed multiple times. Syntax: regex_filter@option_1,option_2,...,option_n. Where regex_filter stands for a list of include and exclude regular expression patterns (Also see --instrumentation_filter). option_1 to option_n stand for arbitrary command line options. If an option contains a comma it has to be quoted with a backslash. Options can contain @. Only the first @ is used to split the string. Example: --host_per_file_copt=//foo/.*.cc,-//foo/bar.cc@-O0 adds the -O0 command line option to the gcc command line of all cc files in //foo/ except bar.cc.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--incompatible_auto_exec_groups"><code><a href="#flag--incompatible_auto_exec_groups">--[no]incompatible_auto_exec_groups</a></code> default: "false"</dt>
<dd>
<p>When enabled, an exec groups is automatically created for each toolchain used by a rule.
For this to work rule needs to specify <code>toolchain</code> parameter on its actions. For
more information, see <a href="https://github.com/bazelbuild/bazel/issues/17134">GH-17134</a>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_merge_genfiles_directory"><code><a href="#flag--incompatible_merge_genfiles_directory">--[no]incompatible_merge_genfiles_directory</a></code> default: "true"</dt>
<dd>
<p>If true, the genfiles directory is folded into the bin directory.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_target_cpu_from_platform"><code><a href="#flag--incompatible_target_cpu_from_platform">--[no]incompatible_target_cpu_from_platform</a></code> default: "true"</dt>
<dd>
<p>If specified, the value of the cpu constraint (<code>@platforms//cpu:cpu</code>) of
the target platform is used to set the <code>$(TARGET_CPU)</code> make variable.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--instrument_test_targets"><code><a href="#flag--instrument_test_targets">--[no]instrument_test_targets</a></code> default: "false"</dt>
<dd>
<p>When coverage is enabled, specifies whether to consider instrumenting test rules.
When set, test rules included by <code>--instrumentation_filter</code> are instrumented.
Otherwise, test rules are always excluded from coverage instrumentation.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--instrumentation_filter"><code><a href="#flag--instrumentation_filter">--instrumentation_filter</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths&gt;</code> default: "-/javatests[/:],-/test/java[/:]"</dt>
<dd>
<p>When coverage is enabled, only rules with names included by the
specified regex-based filter will be instrumented. Rules prefixed
with '-' are excluded instead. Note that only non-test rules are
instrumented unless <code>--instrument_test_targets</code> is enabled.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ios_minimum_os"><code><a href="#flag--ios_minimum_os">--ios_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible iOS version for target simulators and devices. If unspecified, uses 'ios_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--ios_multi_cpus"><code><a href="#flag--ios_multi_cpus">--ios_multi_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures to build an ios_application with. The result is a universal binary containing all specified architectures.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--legacy_whole_archive"><code><a href="#flag--legacy_whole_archive">--[no]legacy_whole_archive</a></code> default: "true"</dt>
<dd>
<p>Deprecated, superseded by --incompatible_remove_legacy_whole_archive (see https://github.com/bazelbuild/bazel/issues/7362 for details). When on, use --whole-archive for cc_binary rules that have linkshared=True and either linkstatic=True or '-static' in linkopts. This is for backwards compatibility only. A better alternative is to use alwayslink=1 where required.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_DEPRECATED"><code>deprecated</code></a>
</p></dd>
<dt id="flag--linkopt"><code><a href="#flag--linkopt">--linkopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to gcc when linking.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ltobackendopt"><code><a href="#flag--ltobackendopt">--ltobackendopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to the LTO backend step (under --features=thin_lto).</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ltoindexopt"><code><a href="#flag--ltoindexopt">--ltoindexopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to the LTO indexing step (under --features=thin_lto).</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--macos_cpus"><code><a href="#flag--macos_cpus">--macos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple macOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--macos_minimum_os"><code><a href="#flag--macos_minimum_os">--macos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible macOS version for targets. If unspecified, uses 'macos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--memprof_profile"><code><a href="#flag--memprof_profile">--memprof_profile</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use memprof profile.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--objc_debug_with_GLIBCXX"><code><a href="#flag--objc_debug_with_GLIBCXX">--[no]objc_debug_with_GLIBCXX</a></code> default: "false"</dt>
<dd>
<p>If set, and compilation mode is set to 'dbg', define GLIBCXX_DEBUG,  GLIBCXX_DEBUG_PEDANTIC and GLIBCPP_CONCEPT_CHECKS.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--objc_enable_binary_stripping"><code><a href="#flag--objc_enable_binary_stripping">--[no]objc_enable_binary_stripping</a></code> default: "false"</dt>
<dd>
<p>Whether to perform symbol and dead-code strippings on linked binaries. Binary strippings will be performed if both this flag and --compilation_mode=opt are specified.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--objccopt"><code><a href="#flag--objccopt">--objccopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to gcc when compiling Objective-C/C++ source files.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--per_file_copt"><code><a href="#flag--per_file_copt">--per_file_copt</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths followed by an @ and a comma separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to selectively pass to gcc when compiling certain files. This option can be passed multiple times. Syntax: regex_filter@option_1,option_2,...,option_n. Where regex_filter stands for a list of include and exclude regular expression patterns (Also see --instrumentation_filter). option_1 to option_n stand for arbitrary command line options. If an option contains a comma it has to be quoted with a backslash. Options can contain @. Only the first @ is used to split the string. Example: --per_file_copt=//foo/.*.cc,-//foo/bar.cc@-O0 adds the -O0 command line option to the gcc command line of all cc files in //foo/ except bar.cc.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--per_file_ltobackendopt"><code><a href="#flag--per_file_ltobackendopt">--per_file_ltobackendopt</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths followed by an @ and a comma separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to selectively pass to LTO backend (under --features=thin_lto) when compiling certain backend objects. This option can be passed multiple times. Syntax: regex_filter@option_1,option_2,...,option_n. Where regex_filter stands for a list of include and exclude regular expression patterns. option_1 to option_n stand for arbitrary command line options. If an option contains a comma it has to be quoted with a backslash. Options can contain @. Only the first @ is used to split the string. Example: --per_file_ltobackendopt=//foo/.*.o,-//foo/bar.o@-O0 adds the -O0 command line option to the LTO backend command line of all o files in //foo/ except bar.o.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--platform_suffix"><code><a href="#flag--platform_suffix">--platform_suffix</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specifies a suffix to be added to the configuration directory.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--propeller_optimize"><code><a href="#flag--propeller_optimize">--propeller_optimize</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use Propeller profile information to optimize the build target.A propeller profile must consist of at least one of two files, a cc profile and a ld profile.  This flag accepts a build label which must refer to the propeller profile input files. For example, the BUILD file that defines the label, in a/b/BUILD:propeller_optimize(    name = &quot;propeller_profile&quot;,    cc_profile = &quot;propeller_cc_profile.txt&quot;,    ld_profile = &quot;propeller_ld_profile.txt&quot;,)An exports_files directive may have to be added to the corresponding package to make these files visible to Bazel. The option must be used as: --propeller_optimize=//a/b:propeller_profile</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--propeller_optimize_absolute_cc_profile"><code><a href="#flag--propeller_optimize_absolute_cc_profile">--propeller_optimize_absolute_cc_profile</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Absolute path name of cc_profile file for Propeller Optimized builds.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--propeller_optimize_absolute_ld_profile"><code><a href="#flag--propeller_optimize_absolute_ld_profile">--propeller_optimize_absolute_ld_profile</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Absolute path name of ld_profile file for Propeller Optimized builds.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--run_under"><code><a href="#flag--run_under">--run_under</a>=&lt;a prefix in front of command&gt;</code> default: see description</dt>
<dd>
<p>Prefix to insert before the executables for the <code>test</code> and <code>run</code> commands.
If the value is <code>foo -bar</code>, and the execution command line is <code>test_binary -baz</code>,
then the final command line is <code>foo -bar test_binary -baz</code>.
This can also be a label to an executable target. Some examples are:</p>
<ul>
<li><code>valgrind</code></li>
<li><code>strace</code></li>
<li><code>strace -c</code></li>
<li><code>valgrind --quiet --num-callers=20</code></li>
<li><code>//package:target</code></li>
<li><code>//package:target --options</code></li>
</ul>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--share_native_deps"><code><a href="#flag--share_native_deps">--[no]share_native_deps</a></code> default: "true"</dt>
<dd>
<p>If true, native libraries that contain identical functionality will be shared among different targets</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--stamp"><code><a href="#flag--stamp">--[no]stamp</a></code> default: "false"</dt>
<dd>
<p>Stamp binaries with the date, username, hostname, workspace information, etc.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--strip"><code><a href="#flag--strip">--strip</a>=&lt;always, sometimes or never&gt;</code> default: "sometimes"</dt>
<dd>
<p>Specifies whether to strip binaries and shared libraries  (using &quot;-Wl,--strip-debug&quot;).  The default value of 'sometimes' means strip iff --compilation_mode=fastbuild.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--stripopt"><code><a href="#flag--stripopt">--stripopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to strip when generating a '&lt;name&gt;.stripped' binary.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--tvos_cpus"><code><a href="#flag--tvos_cpus">--tvos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple tvOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--tvos_minimum_os"><code><a href="#flag--tvos_minimum_os">--tvos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible tvOS version for target simulators and devices. If unspecified, uses 'tvos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--visionos_cpus"><code><a href="#flag--visionos_cpus">--visionos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple visionOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--watchos_cpus"><code><a href="#flag--watchos_cpus">--watchos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple watchOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--watchos_minimum_os"><code><a href="#flag--watchos_minimum_os">--watchos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible watchOS version for target simulators and devices. If unspecified, uses 'watchos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--xbinary_fdo"><code><a href="#flag--xbinary_fdo">--xbinary_fdo</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use XbinaryFDO profile information to optimize compilation. Specify the name of default cross binary profile. When the option is used together with --fdo_instrument/--fdo_optimize/--fdo_profile, those options will always prevail as if xbinary_fdo is never specified.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
</dl>
<dl>Options that affect how strictly Bazel enforces valid build inputs (rule definitions,  flag combinations, etc.):
<dt id="flag--check_visibility"><code><a href="#flag--check_visibility">--[no]check_visibility</a></code> default: "true"</dt>
<dd>
<p>If disabled, visibility errors in target dependencies are demoted to warnings.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--desugar_for_android"><code><a href="#flag--desugar_for_android">--[no]desugar_for_android</a></code> default: "true"</dt>
<dd>
<p>Whether to desugar Java 8 bytecode before dexing.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--desugar_java8_libs"><code><a href="#flag--desugar_java8_libs">--[no]desugar_java8_libs</a></code> default: "false"</dt>
<dd>
<p>Whether to include supported Java 8 libraries in apps for legacy devices.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--enforce_constraints"><code><a href="#flag--enforce_constraints">--[no]enforce_constraints</a></code> default: "true"</dt>
<dd>
<p>Checks the environments each target is compatible with and reports errors if any target has dependencies that don't support the same environments</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="flag--experimental_check_desugar_deps"><code><a href="#flag--experimental_check_desugar_deps">--[no]experimental_check_desugar_deps</a></code> default: "true"</dt>
<dd>
<p>Whether to double-check correct desugaring at Android binary level.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_enforce_transitive_visibility"><code><a href="#flag--experimental_enforce_transitive_visibility">--[no]experimental_enforce_transitive_visibility</a></code> default: "false"</dt>
<dd>
<p>If true, enable package()s to set the transitive_visibility attribute to restrict which packages may depend on them.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_one_version_enforcement"><code><a href="#flag--experimental_one_version_enforcement">--experimental_one_version_enforcement</a>=&lt;off, warning or error&gt;</code> default: "OFF"</dt>
<dd>
<p>When enabled, enforce that a java_binary rule can't contain more than one version of the same class file on the classpath. This enforcement can break the build, or can just result in warnings.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--experimental_strict_java_deps"><code><a href="#flag--experimental_strict_java_deps">--experimental_strict_java_deps</a>=&lt;off, warn, error, strict or default&gt;</code> default: "default"</dt>
<dd>
<p>If true, checks that a Java target explicitly declares all directly used targets as dependencies.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="flag--incompatible_check_testonly_for_output_files"><code><a href="#flag--incompatible_check_testonly_for_output_files">--[no]incompatible_check_testonly_for_output_files</a></code> default: "false"</dt>
<dd>
<p>If enabled, check testonly for prerequisite targets that are output files by looking up the testonly of the generating rule. This matches visibility checking.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_disable_native_android_rules"><code><a href="#flag--incompatible_disable_native_android_rules">--[no]incompatible_disable_native_android_rules</a></code> default: "false"</dt>
<dd>
<p>If enabled, direct usage of the native Android rules is disabled. Please use the Starlark Android rules from https://github.com/bazelbuild/rules_android</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_disable_native_apple_binary_rule"><code><a href="#flag--incompatible_disable_native_apple_binary_rule">--[no]incompatible_disable_native_apple_binary_rule</a></code> default: "false"</dt>
<dd>
<p>No-op. Kept here for backwards compatibility.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--one_version_enforcement_on_java_tests"><code><a href="#flag--one_version_enforcement_on_java_tests">--[no]one_version_enforcement_on_java_tests</a></code> default: "true"</dt>
<dd>
<p>When enabled, and with experimental_one_version_enforcement set to a non-NONE value, enforce one version on java_test targets. This flag can be disabled to improve incremental test performance at the expense of missing potential one version violations.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--python_native_rules_allowlist"><code><a href="#flag--python_native_rules_allowlist">--python_native_rules_allowlist</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>An allowlist (package_group target) to use when enforcing --incompatible_python_disallow_native_rules.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--strict_filesets"><code><a href="#flag--strict_filesets">--[no]strict_filesets</a></code> default: "false"</dt>
<dd>
<p>If this option is enabled, filesets crossing package boundaries are reported as errors.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="flag--strict_proto_deps"><code><a href="#flag--strict_proto_deps">--strict_proto_deps</a>=&lt;off, warn, error, strict or default&gt;</code> default: "error"</dt>
<dd>
<p>Unless OFF, checks that a proto_library target explicitly declares all directly used targets as dependencies.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--strict_public_imports"><code><a href="#flag--strict_public_imports">--strict_public_imports</a>=&lt;off, warn, error, strict or default&gt;</code> default: "off"</dt>
<dd>
<p>Unless OFF, checks that a proto_library target explicitly declares all targets used in 'import public' as exported.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--strict_system_includes"><code><a href="#flag--strict_system_includes">--[no]strict_system_includes</a></code> default: "false"</dt>
<dd>
<p>If true, headers found through system include paths (-isystem) are also required to be declared.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="flag--target_environment"><code><a href="#flag--target_environment">--target_environment</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Declares this build's target environment. Must be a label reference to an
<a href="https://github.com/bazelbuild/bazel/blob/master/src/main/java/com/google/devtools/build/lib/analysis/constraints/EnvironmentRule.java"><code>environment</code> rule</a>. If specified, all top-level targets must be compatible with this
environment.</p>
<p>See also <code>--platforms</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
</dl>
<dl>Options that affect the signing outputs of a build:
<dt id="flag--apk_signing_method"><code><a href="#flag--apk_signing_method">--apk_signing_method</a>=&lt;v1, v2, v1_v2 or v4&gt;</code> default: "v1_v2"</dt>
<dd>
<p>Implementation to use to sign APKs</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--device_debug_entitlements"><code><a href="#flag--device_debug_entitlements">--[no]device_debug_entitlements</a></code> default: "true"</dt>
<dd>
<p>If set, and compilation mode is not 'opt', objc apps will include debug entitlements when signing.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="flag--ios_signing_cert_name"><code><a href="#flag--ios_signing_cert_name">--ios_signing_cert_name</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Certificate name to use for iOS signing. If not set will fall back to provisioning profile. May be the certificate's keychain identity preference or (substring) of the certificate's common name, as per codesign's man page (SIGNING IDENTITIES).</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
</dl>
<dl>This option affects semantics of the Starlark language or the build API accessible to BUILD files, .bzl files, or WORKSPACE files.:
<dt id="flag--incompatible_disallow_sdk_frameworks_attributes"><code><a href="#flag--incompatible_disallow_sdk_frameworks_attributes">--[no]incompatible_disallow_sdk_frameworks_attributes</a></code> default: "false"</dt>
<dd>
<p>If true, disallow sdk_frameworks and weak_sdk_frameworks attributes in objc_library andobjc_import.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_objc_alwayslink_by_default"><code><a href="#flag--incompatible_objc_alwayslink_by_default">--[no]incompatible_objc_alwayslink_by_default</a></code> default: "false"</dt>
<dd>
<p>If true, make the default value true for alwayslink attributes in objc_library and objc_import.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_python_disallow_native_rules"><code><a href="#flag--incompatible_python_disallow_native_rules">--[no]incompatible_python_disallow_native_rules</a></code> default: "false"</dt>
<dd>
<p>When true, an error occurs when using the builtin py_* rules; instead the rule_python rules should be used. See https://github.com/bazelbuild/bazel/issues/17773 for more information and migration instructions.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options that govern the behavior of the test environment or test runner:
<dt id="flag--allow_analysis_failures"><code><a href="#flag--allow_analysis_failures">--[no]allow_analysis_failures</a></code> default: "false"</dt>
<dd>
<p>If true, an analysis failure of a rule target results in the target's propagation
of an instance of <code>AnalysisFailureInfo</code> containing the error description, instead
of resulting in a build failure.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--analysis_testing_deps_limit"><code><a href="#flag--analysis_testing_deps_limit">--analysis_testing_deps_limit</a>=&lt;an integer&gt;</code> default: "2000"</dt>
<dd>
<p>Sets the maximum number of transitive dependencies through a rule attribute with
a <code>for_analysis_testing</code> configuration transition.
Exceeding this limit will result in a rule error.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--break_build_on_parallel_dex2oat_failure"><code><a href="#flag--break_build_on_parallel_dex2oat_failure">--[no]break_build_on_parallel_dex2oat_failure</a></code> default: "false"</dt>
<dd>
<p>If true dex2oat action failures will cause the build to break instead of executing dex2oat during test runtime.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--default_test_resources"><code><a href="#flag--default_test_resources">--default_test_resources</a>=&lt;a resource name followed by equal and 1 float or 4 float, e.g memory=10,30,60,100&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Override the default resources amount for tests. The expected format is
<code>{resource}={value}</code>. If a single positive number is specified as <code>{value}</code>
it will override the default resources for all test sizes. If 4
comma-separated numbers are specified, they will override the resource
amount for respectively the <code>small</code>, <code>medium</code>, <code>large</code>, <code>enormous</code> test sizes.
Values can also be <code>HOST_RAM</code>/<code>HOST_CPU</code>, optionally followed
by <code>[-|*]{float}</code> (eg. <code>memory=HOST_RAM*.1,HOST_RAM*.2,HOST_RAM*.3,HOST_RAM*.4</code>).
The default test resources specified by this flag are overridden by explicit
resources specified in tags.</p>
</dd>
<dt id="flag--experimental_android_use_parallel_dex2oat"><code><a href="#flag--experimental_android_use_parallel_dex2oat">--[no]experimental_android_use_parallel_dex2oat</a></code> default: "false"</dt>
<dd>
<p>Use dex2oat in parallel to possibly speed up android_test.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--ios_memleaks"><code><a href="#flag--ios_memleaks">--[no]ios_memleaks</a></code> default: "false"</dt>
<dd>
<p>Enable checking for memory leaks in ios_test targets.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--ios_simulator_device"><code><a href="#flag--ios_simulator_device">--ios_simulator_device</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The device to simulate when running an iOS application in the simulator, e.g. 'iPhone 6'. You can get a list of devices by running 'xcrun simctl list devicetypes' on the machine the simulator will be run on.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
<dt id="flag--ios_simulator_version"><code><a href="#flag--ios_simulator_version">--ios_simulator_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>The version of iOS to run on the simulator when running or testing. This is ignored for ios_test rules if a target device is specified in the rule.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
<dt id="flag--runs_per_test"><code><a href="#flag--runs_per_test">--runs_per_test</a>=&lt;a positive integer or test_regex@runs. This flag may be passed more than once&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies number of times to run each test. If any of those attempts fail for any
reason, the whole test is considered failed. Normally the value specified is
just an integer.</p>
<p>Example: <code>--runs_per_test=3</code> will run all tests 3 times.</p>
<p>Alternate syntax: <code>regex_filter@runs_per_test</code>. Where <code>runs_per_test</code> stands for
an integer value and <code>regex_filter</code> stands for a list of include and exclude
regular expression patterns (Also see --instrumentation_filter).</p>
<p>Example: <code>--runs_per_test=//foo/.*,-//foo/bar/.*@3</code> runs all tests in <code>//foo/</code> except
those under <code>//foo/bar</code> three times. This option can be passed multiple times. The most
recently passed argument that matches takes precedence. If nothing matches,
the test is only run once.</p>
</dd>
<dt id="flag--test_env"><code><a href="#flag--test_env">--test_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies additional environment variables to be injected into the test runner
environment. Variables can be either specified by <code>name</code>, in which
case its value will be read from the Bazel client environment, or by the
<code>name=value</code> pair.
Previously set variables can be unset via <code>=name</code>.
This option can be used multiple times to specify several variables.
Used only by the 'bazel test' command.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
<dt id="flag--test_timeout"><code><a href="#flag--test_timeout">--test_timeout</a>=&lt;a single integer or comma-separated list of 4 integers&gt;</code> default: "-1"</dt>
<dd>
<p>Override the default test timeout values for test timeouts (in secs). If a single
positive integer value is specified it will override all categories.  If 4
comma-separated integers are specified, they will override the timeouts for
<code>short</code>, <code>moderate</code>, <code>long</code> and <code>eternal</code> (in that order). In either form, a value of
-1 tells blaze to use its default timeouts for that category.</p>
</dd>
<dt id="flag--zip_undeclared_test_outputs"><code><a href="#flag--zip_undeclared_test_outputs">--[no]zip_undeclared_test_outputs</a></code> default: "false"</dt>
<dd>
<p>If true, undeclared test outputs will be archived in a zip file.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
</dl>
<dl>Options that trigger optimizations of the build time:
<dt id="flag--cc_dotd_files"><code><a href="#flag--cc_dotd_files">--[no]cc_dotd_files</a></code> default: "true"</dt>
<dd>
<p>Whether to generate and analyze .d files.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="flag--cc_include_scanning"><code><a href="#flag--cc_include_scanning">--[no]cc_include_scanning</a></code> default: "false"</dt>
<dd>
<p>Whether to narrow inputs to C/C++ compilation by parsing #include lines from input files. This can improve performance and incrementality by decreasing the size of compilation input trees. However, it can also break builds because the include scanner does not fully implement C preprocessor semantics. In particular, it does not understand dynamic #include directives and ignores preprocessor conditional logic. Use at your own risk. Any issues relating to this flag that are filed will be closed. At Google without this flag your build will most likely fail.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_filter_library_jar_with_program_jar"><code><a href="#flag--experimental_filter_library_jar_with_program_jar">--[no]experimental_filter_library_jar_with_program_jar</a></code> default: "false"</dt>
<dd>
<p>Filter the ProGuard ProgramJar to remove any classes also present in the LibraryJar.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_inmemory_dotd_files"><code><a href="#flag--experimental_inmemory_dotd_files">--[no]experimental_inmemory_dotd_files</a></code> default: "true"</dt>
<dd>
<p>If enabled, C++ .d files will be passed through in memory directly from the remote build nodes instead of being written to disk.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_inmemory_jdeps_files"><code><a href="#flag--experimental_inmemory_jdeps_files">--[no]experimental_inmemory_jdeps_files</a></code> default: "true"</dt>
<dd>
<p>If enabled, the dependency (.jdeps) files generated from Java compilations will be passed through in memory directly from the remote build nodes instead of being written to disk.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_retain_test_configuration_across_testonly"><code><a href="#flag--experimental_retain_test_configuration_across_testonly">--[no]experimental_retain_test_configuration_across_testonly</a></code> default: "false"</dt>
<dd>
<p>When enabled, <code>--trim_test_configuration</code> will not trim the test configuration for rules
marked testonly=1. This is meant to reduce action conflict issues when non-test
rules depend on <code>cc_test</code> rules. No effect if <code>--trim_test_configuration</code> is
false.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_unsupported_and_brittle_include_scanning"><code><a href="#flag--experimental_unsupported_and_brittle_include_scanning">--[no]experimental_unsupported_and_brittle_include_scanning</a></code> default: "false"</dt>
<dd>
<p>Whether to narrow inputs to C/C++ compilation by parsing #include lines from input files. This can improve performance and incrementality by decreasing the size of compilation input trees. However, it can also break builds because the include scanner does not fully implement C preprocessor semantics. In particular, it does not understand dynamic #include directives and ignores preprocessor conditional logic. Use at your own risk. Any issues relating to this flag that are filed will be closed. At Google without this flag your build will most likely fail.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--incremental_dexing"><code><a href="#flag--incremental_dexing">--[no]incremental_dexing</a></code> default: "true"</dt>
<dd>
<p>Does most of the work for dexing separately for each Jar file.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--objc_use_dotd_pruning"><code><a href="#flag--objc_use_dotd_pruning">--[no]objc_use_dotd_pruning</a></code> default: "true"</dt>
<dd>
<p>If set, .d files emitted by clang will be used to prune the set of inputs passed into objc compiles.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--process_headers_in_dependencies"><code><a href="#flag--process_headers_in_dependencies">--[no]process_headers_in_dependencies</a></code> default: "false"</dt>
<dd>
<p>When building a target //a:a, process headers in all targets that //a:a depends on (if header processing is enabled for the toolchain).</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--trim_test_configuration"><code><a href="#flag--trim_test_configuration">--[no]trim_test_configuration</a></code> default: "true"</dt>
<dd>
<p>When enabled, test-related options will be cleared below the top level of the build. When this flag is active, tests cannot be built as dependencies of non-test rules, but changes to test-related options will not cause non-test rules to be re-analyzed.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
</dl>
<dl>Options that affect the verbosity, format or location of logging:
<dt id="flag--toolchain_resolution_debug"><code><a href="#flag--toolchain_resolution_debug">--toolchain_resolution_debug</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths&gt;</code> default: "-.*"</dt>
<dd>
<p>Print debug information during toolchain resolution. The flag takes a regex, which is checked against toolchain types and specific targets to see which to debug. Multiple regexes may be  separated by commas, and then each regex is checked separately. Note: The output of this flag is very complex and will likely only be useful to experts in toolchain resolution.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="flag--verbose_visibility_errors"><code><a href="#flag--verbose_visibility_errors">--[no]verbose_visibility_errors</a></code> default: "false"</dt>
<dd>
<p>If enabled, visibility errors include additional diagnostic information.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
</dl>
<dl>Options specifying or altering a generic input to a Bazel command that does not fall into other categories.:
<dt id="flag--flag_alias"><code><a href="#flag--flag_alias">--flag_alias</a>=&lt;a &#39;name=value&#39; flag alias&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Sets a shorthand name for a Starlark flag. It takes a single key-value pair in the form
<code>{key}={value}</code> as an argument.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--incompatible_default_to_explicit_init_py"><code><a href="#flag--incompatible_default_to_explicit_init_py">--[no]incompatible_default_to_explicit_init_py</a></code> default: "false"</dt>
<dd>
<p>This flag changes the default behavior so that <strong>init</strong>.py files are no longer automatically created in the runfiles of Python targets. Precisely, when a py_binary or py_test target has legacy_create_init set to &quot;auto&quot; (the default), it is treated as false if and only if this flag is set. See https://github.com/bazelbuild/bazel/issues/10076.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Miscellaneous options, not otherwise categorized.:
<dt id="flag--cache_test_results"><code><a href="#flag--cache_test_results">--[no]cache_test_results</a></code> [<code>-t</code>] default: "auto"</dt>
<dd>
<p>If set to <code>auto</code>, Bazel reruns a test if and only if:</p>
<ol>
<li>Bazel detects changes in the test or its dependencies,</li>
<li>The test is marked as <code>external</code>,</li>
<li>Multiple test runs were requested with <code>--runs_per_test</code>, or</li>
<li>The test previously failed.
If set to <code>yes</code>, Bazel caches all test results except for tests marked as
<code>external</code>. If set to <code>no</code>, Bazel does not cache any test results.</li>
</ol>
</dd>
<dt id="flag--experimental_cancel_concurrent_tests"><code><a href="#flag--experimental_cancel_concurrent_tests">--[no]experimental_cancel_concurrent_tests</a></code> default: "never"</dt>
<dd>
<p>If <code>on_failed</code> or <code>on_passed</code>, then Blaze will cancel concurrently running tests on the first
successful run with that result. This is only useful in combination with
<code>--runs_per_test_detects_flakes</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_fetch_all_coverage_outputs"><code><a href="#flag--experimental_fetch_all_coverage_outputs">--[no]experimental_fetch_all_coverage_outputs</a></code> default: "false"</dt>
<dd>
<p>If true, then Bazel fetches the entire coverage data directory for each test during a coverage run.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_generate_llvm_lcov"><code><a href="#flag--experimental_generate_llvm_lcov">--[no]experimental_generate_llvm_lcov</a></code> default: "false"</dt>
<dd>
<p>If true, coverage for clang will generate an LCOV report.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_java_classpath"><code><a href="#flag--experimental_java_classpath">--experimental_java_classpath</a>=&lt;off, javabuilder, bazel or bazel_no_fallback&gt;</code> default: "bazel"</dt>
<dd>
<p>Enables reduced classpaths for Java compilations.</p>
</dd>
<dt id="flag--experimental_run_android_lint_on_java_rules"><code><a href="#flag--experimental_run_android_lint_on_java_rules">--[no]experimental_run_android_lint_on_java_rules</a></code> default: "false"</dt>
<dd>
<p>Whether to validate java_* sources.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--explicit_java_test_deps"><code><a href="#flag--explicit_java_test_deps">--[no]explicit_java_test_deps</a></code> default: "false"</dt>
<dd>
<p>Explicitly specify a dependency to JUnit or Hamcrest in a java_test instead of  accidentally obtaining from the TestRunner's deps. Only works for bazel right now.</p>
</dd>
<dt id="flag--host_java_launcher"><code><a href="#flag--host_java_launcher">--host_java_launcher</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The Java launcher used by tools that are executed during a build.</p>
</dd>
<dt id="flag--host_javacopt"><code><a href="#flag--host_javacopt">--host_javacopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to javac when building tools that are executed during a build.</p>
</dd>
<dt id="flag--host_jvmopt"><code><a href="#flag--host_jvmopt">--host_jvmopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the Java VM when building tools that are executed during  the build. These options will get added to the VM startup options of each  java_binary target.</p>
</dd>
<dt id="flag--incompatible_check_sharding_support"><code><a href="#flag--incompatible_check_sharding_support">--[no]incompatible_check_sharding_support</a></code> default: "true"</dt>
<dd>
<p>If true, Bazel will fail a sharded test if the test runner does not indicate that it
supports sharding by touching the file at the path in <code>TEST_SHARD_STATUS_FILE</code>.
If false, a test runner that does not support sharding will lead to all tests
running in each shard.</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_exclusive_test_sandboxed"><code><a href="#flag--incompatible_exclusive_test_sandboxed">--[no]incompatible_exclusive_test_sandboxed</a></code> default: "true"</dt>
<dd>
<p>If true, exclusive tests will run with sandboxed strategy. Add <code>local</code> tag to force
an exclusive test run locally</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_strict_action_env"><code><a href="#flag--incompatible_strict_action_env">--[no]incompatible_strict_action_env</a></code> default: "false"</dt>
<dd>
<p>If true, Bazel uses an environment with a static value for PATH and does not
inherit <code>LD_LIBRARY_PATH</code>. Use <code>--action_env=ENV_VARIABLE</code> if you want to
inherit specific environment variables from the client, but note that doing so
can prevent cross-user caching if a shared cache is used.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--j2objc_translation_flags"><code><a href="#flag--j2objc_translation_flags">--j2objc_translation_flags</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the J2ObjC tool.</p>
</dd>
<dt id="flag--java_debug"><code><a href="#flag--java_debug">--java_debug</a></code></dt>
<dd>
<p>Causes the Java virtual machine of a java test to wait for a connection from a JDWP-compliant debugger (such as jdb) before starting the test. Implies -test_output=streamed.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--test_arg">--test_arg=--wrapper_script_flag=--debug</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--test_output">--test_output=streamed</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--test_strategy">--test_strategy=exclusive</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--test_timeout">--test_timeout=9999</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--nocache_test_results">--nocache_test_results</a></code>
</p></dd>
<dt id="flag--java_deps"><code><a href="#flag--java_deps">--[no]java_deps</a></code> default: "true"</dt>
<dd>
<p>Generate dependency information (for now, compile-time classpath) per Java target.</p>
</dd>
<dt id="flag--java_header_compilation"><code><a href="#flag--java_header_compilation">--[no]java_header_compilation</a></code> default: "true"</dt>
<dd>
<p>Compile ijars directly from source.</p>
</dd>
<dt id="flag--java_language_version"><code><a href="#flag--java_language_version">--java_language_version</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The Java language version</p>
</dd>
<dt id="flag--java_launcher"><code><a href="#flag--java_launcher">--java_launcher</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The Java launcher to use when building Java binaries.  If this flag is set to the empty string, the JDK launcher is used. The &quot;launcher&quot; attribute overrides this flag.</p>
</dd>
<dt id="flag--java_runtime_version"><code><a href="#flag--java_runtime_version">--java_runtime_version</a>=&lt;a string&gt;</code> default: "local_jdk"</dt>
<dd>
<p>The Java runtime version</p>
</dd>
<dt id="flag--javacopt"><code><a href="#flag--javacopt">--javacopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to javac.</p>
</dd>
<dt id="flag--jvmopt"><code><a href="#flag--jvmopt">--jvmopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the Java VM. These options will get added to the VM startup options of each java_binary target.</p>
</dd>
<dt id="flag--legacy_main_dex_list_generator"><code><a href="#flag--legacy_main_dex_list_generator">--legacy_main_dex_list_generator</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies a binary to use to generate the list of classes that must be in the main dex when compiling legacy multidex.</p>
</dd>
<dt id="flag--optimizing_dexer"><code><a href="#flag--optimizing_dexer">--optimizing_dexer</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies a binary to use to do dexing without sharding.</p>
</dd>
<dt id="flag--plugin"><code><a href="#flag--plugin">--plugin</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Plugins to use in the build. Currently works with java_plugin.</p>
</dd>
<dt id="flag--proguard_top"><code><a href="#flag--proguard_top">--proguard_top</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies which version of ProGuard to use for code removal when building a Java binary.</p>
</dd>
<dt id="flag--proto_compiler"><code><a href="#flag--proto_compiler">--proto_compiler</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:protoc"</dt>
<dd>
<p>The label of the proto-compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_profile"><code><a href="#flag--proto_profile">--[no]proto_profile</a></code> default: "true"</dt>
<dd>
<p>Whether to pass profile_path to the proto compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_profile_path"><code><a href="#flag--proto_profile_path">--proto_profile_path</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The profile to pass to the proto compiler as profile_path. If unset, but  --proto_profile is true (the default), infers the path from --fdo_optimize.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_cc"><code><a href="#flag--proto_toolchain_for_cc">--proto_toolchain_for_cc</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:cc_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile C++ protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_j2objc"><code><a href="#flag--proto_toolchain_for_j2objc">--proto_toolchain_for_j2objc</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/j2objc:j2objc_proto_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile j2objc protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_java"><code><a href="#flag--proto_toolchain_for_java">--proto_toolchain_for_java</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:java_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile Java protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_javalite"><code><a href="#flag--proto_toolchain_for_javalite">--proto_toolchain_for_javalite</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:javalite_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile JavaLite protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--protocopt"><code><a href="#flag--protocopt">--protocopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the protobuf compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--runs_per_test_detects_flakes"><code><a href="#flag--runs_per_test_detects_flakes">--[no]runs_per_test_detects_flakes</a></code> default: "false"</dt>
<dd>
<p>If true, any shard in which at least one run/attempt passes and at least one run/attempt fails gets a FLAKY status.</p>
</dd>
<dt id="flag--shell_executable"><code><a href="#flag--shell_executable">--shell_executable</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>Absolute path to the shell executable for Bazel to use. If this is unset, but the
<code>BAZEL_SH</code> environment variable is set on the first Bazel invocation (that starts
up a Bazel server), Bazel uses that. If neither is set, Bazel uses a hard-coded
default path depending on the operating system it runs on;</p>
<ul>
<li>Windows: <code>c:/msys64/usr/bin/bash.exe</code></li>
<li>FreeBSD: <code>/usr/local/bin/bash</code></li>
<li>All others: <code>/bin/bash</code>.</li>
</ul>
<p>Note that using a shell that is not compatible with <code>bash</code> may lead
to build failures or runtime failures of the generated binaries.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--test_arg"><code><a href="#flag--test_arg">--test_arg</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies additional options and arguments that should be passed to the test
executable. Can be used multiple times to specify several arguments.
If multiple tests are executed, each of them will receive identical arguments.
Used only by the <code>bazel test</code> command.</p>
</dd>
<dt id="flag--test_filter"><code><a href="#flag--test_filter">--test_filter</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specifies a filter to forward to the test framework.  Used to limit the tests run. Note that this does not affect which targets are built.</p>
</dd>
<dt id="flag--test_result_expiration"><code><a href="#flag--test_result_expiration">--test_result_expiration</a>=&lt;an integer&gt;</code> default: "-1"</dt>
<dd>
<p>This option is deprecated and has no effect.</p>
</dd>
<dt id="flag--test_runner_fail_fast"><code><a href="#flag--test_runner_fail_fast">--[no]test_runner_fail_fast</a></code> default: "false"</dt>
<dd>
<p>Forwards fail fast option to the test runner. The test runner should stop execution upon first failure.</p>
</dd>
<dt id="flag--test_sharding_strategy"><code><a href="#flag--test_sharding_strategy">--test_sharding_strategy</a>=&lt;explicit, disabled or forced=k where k is the number of shards to enforce&gt;</code> default: "explicit"</dt>
<dd>
<p>Specify strategy for test sharding:</p>
<ul>
<li><code>explicit</code> to only use sharding if the <code>shard_count</code> <code>BUILD</code> attribute is
present.</li>
<li><code>disabled</code> to never use test sharding.</li>
<li><code>forced=k</code> to enforce <code>k</code> shards for testing regardless of the <code>shard_count</code> <code>BUILD</code>
attribute.</li>
</ul>
</dd>
<dt id="flag--tool_java_language_version"><code><a href="#flag--tool_java_language_version">--tool_java_language_version</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The Java language version used to execute the tools that are needed during a build</p>
</dd>
<dt id="flag--tool_java_runtime_version"><code><a href="#flag--tool_java_runtime_version">--tool_java_runtime_version</a>=&lt;a string&gt;</code> default: "remotejdk_11"</dt>
<dd>
<p>The Java runtime version used to execute tools during the build</p>
</dd>
<dt id="flag--use_ijars"><code><a href="#flag--use_ijars">--[no]use_ijars</a></code> default: "true"</dt>
<dd>
<p>If enabled, this option causes Java compilation to use interface jars. This will result in faster incremental compilation, but error messages can be different.</p>
</dd>
</dl>

<h2><a name="build">Build Options</a></h2>
<dl>Options that control build execution:
<dt id="build-flag--allow_one_action_on_resource_unavailable"><code id="allow_one_action_on_resource_unavailable"><a href="#build-flag--allow_one_action_on_resource_unavailable">--[no]allow_one_action_on_resource_unavailable</a></code> default: "true"</dt>
<dd>
<p>If set, allow at least one action to run even if the resource is not enough or unavailable.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--check_up_to_date"><code id="check_up_to_date"><a href="#build-flag--check_up_to_date">--[no]check_up_to_date</a></code> default: "false"</dt>
<dd>
<p>Don't perform the build, just check if it is up-to-date.  If all targets are up-to-date, the build completes successfully.  If any step needs to be executed an error is reported and the build fails.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--dynamic_local_execution_delay"><code id="dynamic_local_execution_delay"><a href="#build-flag--dynamic_local_execution_delay">--dynamic_local_execution_delay</a>=&lt;an integer&gt;</code> default: "1000"</dt>
<dd>
<p>How many milliseconds should local execution be delayed, if remote execution was faster during a build at least once?</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--dynamic_local_strategy"><code id="dynamic_local_strategy"><a href="#build-flag--dynamic_local_strategy">--dynamic_local_strategy</a>=&lt;a &#39;[name=]value1[,..,valueN]&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The local strategies, in order, to use for the given mnemonic - the first applicable strategy is used. For example, <code>worker,sandboxed</code> runs actions that support persistent workers using the worker strategy, and all others using the sandboxed strategy. If no mnemonic is given, the list of strategies is used as the fallback for all mnemonics. The default fallback list is <code>worker,sandboxed</code>, or<code>worker,sandboxed,standalone</code> if <code>experimental_local_lockfree_output</code> is set. Takes [mnemonic=]local_strategy[,local_strategy,...]</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--dynamic_remote_strategy"><code id="dynamic_remote_strategy"><a href="#build-flag--dynamic_remote_strategy">--dynamic_remote_strategy</a>=&lt;a &#39;[name=]value1[,..,valueN]&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The remote strategies, in order, to use for the given mnemonic - the first applicable strategy is used. If no mnemonic is given, the list of strategies is used as the fallback for all mnemonics. The default fallback list is <code>remote</code>, so this flag usually does not need to be set explicitly. Takes [mnemonic=]remote_strategy[,remote_strategy,...]</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--experimental_async_execution"><code id="experimental_async_execution"><a href="#build-flag--experimental_async_execution">--[no]experimental_async_execution</a></code> default: "false"</dt>
<dd>
<p>If set to true, Bazel is allowed to run action in a virtual thread. The number of
actions in flight is still capped with <code>--jobs</code>.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="build-flag--experimental_async_execution_max_concurrent_actions"><code id="experimental_async_execution_max_concurrent_actions"><a href="#build-flag--experimental_async_execution_max_concurrent_actions">--experimental_async_execution_max_concurrent_actions</a>=&lt;an integer&gt;</code> default: "5000"</dt>
<dd>
<p>The number of maximum concurrent actions to run with async execution. If the value is
less than <code>--jobs</code>, it is clamped to <code>--jobs</code>.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_docker_image"><code id="experimental_docker_image"><a href="#build-flag--experimental_docker_image">--experimental_docker_image</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Specify a Docker image name (e.g. &quot;ubuntu:latest&quot;) that should be used to execute a sandboxed action when using the docker strategy and the action itself doesn't already have a container-image attribute in its remote_execution_properties in the platform description. The value of this flag is passed verbatim to 'docker run', so it supports the same syntax and mechanisms as Docker itself.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_docker_use_customized_images"><code id="experimental_docker_use_customized_images"><a href="#build-flag--experimental_docker_use_customized_images">--[no]experimental_docker_use_customized_images</a></code> default: "true"</dt>
<dd>
<p>If enabled, injects the uid and gid of the current user into the Docker image before using it. This is required if your build / tests depend on the user having a name and home directory inside the container. This is on by default, but you can disable it in case the automatic image customization feature doesn't work in your case or you know that you don't need it.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_dynamic_exclude_tools"><code id="experimental_dynamic_exclude_tools"><a href="#build-flag--experimental_dynamic_exclude_tools">--[no]experimental_dynamic_exclude_tools</a></code> default: "true"</dt>
<dd>
<p>When set, targets that are build &quot;for tool&quot; are not subject to dynamic execution. Such targets are extremely unlikely to be built incrementally and thus not worth spending local cycles on.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--experimental_dynamic_local_load_factor"><code id="experimental_dynamic_local_load_factor"><a href="#build-flag--experimental_dynamic_local_load_factor">--experimental_dynamic_local_load_factor</a>=&lt;a double&gt;</code> default: "0"</dt>
<dd>
<p>Controls how much load from dynamic execution to put on the local machine. This flag adjusts how many actions in dynamic execution we will schedule concurrently. It is based on the number of CPUs Blaze thinks is available, which can be controlled with the --local_resources=cpu= flag.
If this flag is 0, all actions are scheduled locally immediately. If &gt; 0, the amount of actions scheduled locally is limited by the number of CPUs available. If &lt; 1, the load factor is used to reduce the number of locally scheduled actions when the number of actions waiting to schedule is high. This lessens the load on the local machine in the clean build case, where the local machine does not contribute much.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--experimental_dynamic_slow_remote_time"><code id="experimental_dynamic_slow_remote_time"><a href="#build-flag--experimental_dynamic_slow_remote_time">--experimental_dynamic_slow_remote_time</a>=&lt;An immutable length of time.&gt;</code> default: "0"</dt>
<dd>
<p>If &gt;0, the time a dynamically run action must run remote-only before we prioritize its local execution to avoid remote timeouts. This may hide some problems on the remote execution system. Do not turn this on without monitoring of remote execution issues.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--experimental_enable_docker_sandbox"><code id="experimental_enable_docker_sandbox"><a href="#build-flag--experimental_enable_docker_sandbox">--[no]experimental_enable_docker_sandbox</a></code> default: "false"</dt>
<dd>
<p>Enable Docker-based sandboxing. This option has no effect if Docker is not installed.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_inmemory_sandbox_stashes"><code id="experimental_inmemory_sandbox_stashes"><a href="#build-flag--experimental_inmemory_sandbox_stashes">--[no]experimental_inmemory_sandbox_stashes</a></code> default: "false"</dt>
<dd>
<p>If set to true, the contents of stashed sandboxes for reuse_sandbox_directories will be tracked in memory. This reduces the amount of I/O needed during reuse. Depending on the build this flag may improve wall time. Depending on the build as well this flag may use a significant amount of additional memory.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_sandbox_async_tree_delete_idle_threads"><code id="experimental_sandbox_async_tree_delete_idle_threads"><a href="#build-flag--experimental_sandbox_async_tree_delete_idle_threads">--experimental_sandbox_async_tree_delete_idle_threads</a>=&lt;an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|*]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS*.5&quot;&gt;</code> default: "4"</dt>
<dd>
<p>If 0, sandboxes are deleted as soon as actions finish, blocking action completion. If greater than 0, sandboxes are deleted asynchronously in the background without blocking action completion. Asynchronous deletion uses a single thread while a command is running, but ramps up to as many threads as the value of this flag once the server becomes idle. Set to <code>auto</code> to use as many threads as the number of CPUs. A server shutdown blocks on any pending asynchronous deletions.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_sandbox_enforce_resources_regexp"><code id="experimental_sandbox_enforce_resources_regexp"><a href="#build-flag--experimental_sandbox_enforce_resources_regexp">--experimental_sandbox_enforce_resources_regexp</a>=&lt;a valid Java regular expression&gt;</code> default: ""</dt>
<dd>
<p>If true, actions whose mnemonic matches the input regex will have their resources request enforced as limits, overriding the value of --experimental_sandbox_limits, if the resource type supports it. For example a test that declares cpu:3 and resources:memory:10, will run with at most 3 cpus and 10 megabytes of memory.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_sandbox_limits"><code id="experimental_sandbox_limits"><a href="#build-flag--experimental_sandbox_limits">--experimental_sandbox_limits</a>=&lt;a named double, &#39;name=value&#39;, where value is an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|*]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS*.5&quot;&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>If &gt; 0, each Linux sandbox will be limited to the given amount for the specified resource. Requires --incompatible_use_new_cgroup_implementation and overrides --experimental_sandbox_memory_limit_mb. Requires cgroups v1 or v2 and permissions for the users to the cgroups dir.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_sandbox_memory_limit_mb"><code id="experimental_sandbox_memory_limit_mb"><a href="#build-flag--experimental_sandbox_memory_limit_mb">--experimental_sandbox_memory_limit_mb</a>=&lt;an integer number of MBs, or &quot;HOST_RAM&quot;, optionally followed by [-|*]&lt;float&gt;.&gt;</code> default: "0"</dt>
<dd>
<p>If &gt; 0, each Linux sandbox will be limited to the given amount of memory (in MB). Requires cgroups v1 or v2 and permissions for the users to the cgroups dir.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_shrink_worker_pool"><code id="experimental_shrink_worker_pool"><a href="#build-flag--experimental_shrink_worker_pool">--[no]experimental_shrink_worker_pool</a></code> default: "false"</dt>
<dd>
<p>If enabled, could shrink worker pool if worker memory pressure is high. This flag works only when flag experimental_total_worker_memory_limit_mb is enabled.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--experimental_total_worker_memory_limit_mb"><code id="experimental_total_worker_memory_limit_mb"><a href="#build-flag--experimental_total_worker_memory_limit_mb">--experimental_total_worker_memory_limit_mb</a>=&lt;an integer number of MBs, or &quot;HOST_RAM&quot;, optionally followed by [-|*]&lt;float&gt;.&gt;</code> default: "0"</dt>
<dd>
<p>If this limit is greater than zero idle workers might be killed if the total memory usage of all  workers exceed the limit.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--experimental_use_hermetic_linux_sandbox"><code id="experimental_use_hermetic_linux_sandbox"><a href="#build-flag--experimental_use_hermetic_linux_sandbox">--[no]experimental_use_hermetic_linux_sandbox</a></code> default: "false"</dt>
<dd>
<p>If set to true, do not mount root, only mount whats provided with sandbox_add_mount_pair. Input files will be hardlinked to the sandbox instead of symlinked to from the sandbox. If action input files are located on a filesystem different from the sandbox, then the input files will be copied instead.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_use_windows_sandbox"><code id="experimental_use_windows_sandbox"><a href="#build-flag--experimental_use_windows_sandbox">--[no]experimental_use_windows_sandbox</a></code> default: "false"</dt>
<dd>
<p>Use Windows sandbox to run actions. If &quot;yes&quot;, the binary provided by --experimental_windows_sandbox_path must be valid and correspond to a supported version of sandboxfs. If &quot;auto&quot;, the binary may be missing or not compatible.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_windows_sandbox_path"><code id="experimental_windows_sandbox_path"><a href="#build-flag--experimental_windows_sandbox_path">--experimental_windows_sandbox_path</a>=&lt;a string&gt;</code> default: "BazelSandbox.exe"</dt>
<dd>
<p>Path to the Windows sandbox binary to use when --experimental_use_windows_sandbox is true. If a bare name, use the first binary of that name found in the PATH.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_worker_allowlist"><code id="experimental_worker_allowlist"><a href="#build-flag--experimental_worker_allowlist">--experimental_worker_allowlist</a>=&lt;comma-separated set of options&gt;</code> default: see description</dt>
<dd>
<p>If non-empty, only allow using persistent workers with the given worker key mnemonic.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--experimental_worker_cancellation"><code id="experimental_worker_cancellation"><a href="#build-flag--experimental_worker_cancellation">--[no]experimental_worker_cancellation</a></code> default: "false"</dt>
<dd>
<p>If enabled, Bazel may send cancellation requests to workers that support them.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_worker_memory_limit_mb"><code id="experimental_worker_memory_limit_mb"><a href="#build-flag--experimental_worker_memory_limit_mb">--experimental_worker_memory_limit_mb</a>=&lt;an integer number of MBs, or &quot;HOST_RAM&quot;, optionally followed by [-|*]&lt;float&gt;.&gt;</code> default: "0"</dt>
<dd>
<p>If this limit is greater than zero, workers might be killed if the memory usage of the worker exceeds the limit. If not used together with dynamic execution and <code>--experimental_dynamic_ignore_local_signals=9</code>, this may crash your build.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--experimental_worker_metrics_poll_interval"><code id="experimental_worker_metrics_poll_interval"><a href="#build-flag--experimental_worker_metrics_poll_interval">--experimental_worker_metrics_poll_interval</a>=&lt;An immutable length of time.&gt;</code> default: "5s"</dt>
<dd>
<p>The interval between collecting worker metrics and possibly attempting evictions. Cannot effectively be less than 1s for performance reasons.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--experimental_worker_multiplex_sandboxing"><code id="experimental_worker_multiplex_sandboxing"><a href="#build-flag--experimental_worker_multiplex_sandboxing">--[no]experimental_worker_multiplex_sandboxing</a></code> default: "false"</dt>
<dd>
<p>If enabled, multiplex workers with a 'supports-multiplex-sandboxing' execution requirement will run in a sandboxed environment, using a separate sandbox directory per work request. Multiplex workers with the execution requirement are always sandboxed when running under the dynamic execution strategy, irrespective of this flag.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_worker_sandbox_hardening"><code id="experimental_worker_sandbox_hardening"><a href="#build-flag--experimental_worker_sandbox_hardening">--[no]experimental_worker_sandbox_hardening</a></code> default: "false"</dt>
<dd>
<p>If enabled, workers are run in a hardened sandbox, if the implementation allows it. If hardening is enabled then tmp directories are distinct for different workers.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_worker_sandbox_inmemory_tracking"><code id="experimental_worker_sandbox_inmemory_tracking"><a href="#build-flag--experimental_worker_sandbox_inmemory_tracking">--experimental_worker_sandbox_inmemory_tracking</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>A worker key mnemonic for which the contents of the sandbox directory are tracked in memory. This may improve build performance at the cost of additional memory usage. Only affects sandboxed workers. May be specified multiple times for different mnemonics.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_worker_strict_flagfiles"><code id="experimental_worker_strict_flagfiles"><a href="#build-flag--experimental_worker_strict_flagfiles">--[no]experimental_worker_strict_flagfiles</a></code> default: "false"</dt>
<dd>
<p>If enabled, actions arguments for workers that do not follow the worker specification will cause an error. Worker arguments must have exactly one @flagfile argument as the last of its list of arguments.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--genrule_strategy"><code id="genrule_strategy"><a href="#build-flag--genrule_strategy">--genrule_strategy</a>=&lt;comma-separated list of options&gt;</code> default: ""</dt>
<dd>
<p>Specify how to execute genrules. This flag will be phased out. Instead, use --spawn_strategy=&lt;value&gt; to control all actions or --strategy=Genrule=&lt;value&gt; to control genrules only.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--incompatible_use_new_cgroup_implementation"><code id="incompatible_use_new_cgroup_implementation"><a href="#build-flag--incompatible_use_new_cgroup_implementation">--[no]incompatible_use_new_cgroup_implementation</a></code> default: "true"</dt>
<dd>
<p>If true, use the new implementation for cgroups. The old implementation only supports the memory controller and ignores the value of --experimental_sandbox_limits.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--internal_spawn_scheduler"><code id="internal_spawn_scheduler"><a href="#build-flag--internal_spawn_scheduler">--[no]internal_spawn_scheduler</a></code> default: "true"</dt>
<dd>
<p>Placeholder option so that we can tell in Blaze whether the spawn scheduler was enabled.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--jobs"><code id="jobs"><a href="#build-flag--jobs">--jobs</a>=&lt;an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|*]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS*.5&quot;&gt;</code> [<code>-j</code>] default: "auto"</dt>
<dd>
<p>The number of concurrent jobs to run. Takes an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|<em>]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS</em>.5&quot;. Values must be between 1 and 5000. Values above 2500 may cause memory issues. &quot;auto&quot; calculates a reasonable default based on host resources.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--keep_going"><code id="keep_going"><a href="#build-flag--keep_going">--[no]keep_going</a></code> [<code>-k</code>] default: "false"</dt>
<dd>
<p>Continue as much as possible after an error.  While the target that failed and those that depend on it cannot be analyzed, other prerequisites of these targets can be.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="build-flag--loading_phase_threads"><code id="loading_phase_threads"><a href="#build-flag--loading_phase_threads">--loading_phase_threads</a>=&lt;an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|*]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS*.5&quot;&gt;</code> default: "auto"</dt>
<dd>
<p>Number of parallel threads to use for the loading/analysis phase.Takes an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|<em>]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS</em>.5&quot;. &quot;auto&quot; sets a reasonable default based on host resources. Must be at least 1.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="build-flag--reuse_sandbox_directories"><code id="reuse_sandbox_directories"><a href="#build-flag--reuse_sandbox_directories">--[no]reuse_sandbox_directories</a></code> default: "true"</dt>
<dd>
<p>If set to true, directories used by sandboxed non-worker execution may be reused to avoid unnecessary setup costs.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--sandbox_base"><code id="sandbox_base"><a href="#build-flag--sandbox_base">--sandbox_base</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Lets the sandbox create its sandbox directories underneath this path. Specify a path on tmpfs (like /run/shm) to possibly improve performance a lot when your build / tests have many input files. Note: You need enough RAM and free space on the tmpfs to hold output and intermediate files generated by running actions.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--sandbox_enable_loopback_device"><code id="sandbox_enable_loopback_device"><a href="#build-flag--sandbox_enable_loopback_device">--[no]sandbox_enable_loopback_device</a></code> default: "true"</dt>
<dd>
<p>If true, a loopback device will be set up in the linux-sandbox network namespace for local actions.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--sandbox_explicit_pseudoterminal"><code id="sandbox_explicit_pseudoterminal"><a href="#build-flag--sandbox_explicit_pseudoterminal">--[no]sandbox_explicit_pseudoterminal</a></code> default: "false"</dt>
<dd>
<p>Explicitly enable the creation of pseudoterminals for sandboxed actions. Some linux distributions require setting the group id of the process to 'tty' inside the sandbox in order for pseudoterminals to function. If this is causing issues, this flag can be disabled to enable other groups to be used.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--sandbox_tmpfs_path"><code id="sandbox_tmpfs_path"><a href="#build-flag--sandbox_tmpfs_path">--sandbox_tmpfs_path</a>=&lt;an absolute path&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>For sandboxed actions, mount an empty, writable directory at this absolute path (if supported by the sandboxing implementation, ignored otherwise).</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--skip_incompatible_explicit_targets"><code id="skip_incompatible_explicit_targets"><a href="#build-flag--skip_incompatible_explicit_targets">--[no]skip_incompatible_explicit_targets</a></code> default: "false"</dt>
<dd>
<p>Skip incompatible targets that are explicitly listed on the command line.
By default, building such targets results in an error but they are
silently skipped when this option is enabled. See: <a href="https://bazel.build/extending/platforms#skipping-incompatible-targets">Skipping incompatible targets</a></p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="build-flag--spawn_strategy"><code id="spawn_strategy"><a href="#build-flag--spawn_strategy">--spawn_strategy</a>=&lt;comma-separated list of options&gt;</code> default: ""</dt>
<dd>
<p>Specify how spawn actions are executed by default. Accepts a comma-separated list of strategies from highest to lowest priority. For each action Bazel picks the strategy with the highest priority that can execute the action. The default value is &quot;remote,worker,sandboxed,local&quot;. See https://blog.bazel.build/2019/06/19/list-strategy.html for details.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--strategy"><code id="strategy"><a href="#build-flag--strategy">--strategy</a>=&lt;a &#39;[name=]value1[,..,valueN]&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specify how to distribute compilation of other spawn actions. Accepts a comma-separated list of strategies from highest to lowest priority. For each action Bazel picks the strategy with the highest priority that can execute the action. The default value is &quot;remote,worker,sandboxed,local&quot;. This flag overrides the values set by --spawn_strategy (and --genrule_strategy if used with mnemonic Genrule). See https://blog.bazel.build/2019/06/19/list-strategy.html for details.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--strategy_regexp"><code id="strategy_regexp"><a href="#build-flag--strategy_regexp">--strategy_regexp</a>=&lt;a &#39;&lt;RegexFilter&gt;=value[,value]&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Override which spawn strategy should be used to execute spawn actions that have descriptions matching a certain regex_filter. See --per_file_copt for details onregex_filter matching. The last regex_filter that matches the description is used. This option overrides other flags for specifying strategy. Example: --strategy_regexp=//foo.<em>.cc,-//foo/bar=local means to run actions using local strategy if their descriptions match //foo.</em>.cc but not //foo/bar. Example: --strategy_regexp='Compiling.*/bar=local  --strategy_regexp=Compiling=sandboxed will run 'Compiling //foo/bar/baz' with the 'local' strategy, but reversing the order would run it with 'sandboxed'.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--worker_extra_flag"><code id="worker_extra_flag"><a href="#build-flag--worker_extra_flag">--worker_extra_flag</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Extra command-flags that will be passed to worker processes in addition to --persistent_worker, keyed by mnemonic (e.g. --worker_extra_flag=Javac=--debug.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--worker_max_instances"><code id="worker_max_instances"><a href="#build-flag--worker_max_instances">--worker_max_instances</a>=&lt;[name=]value, where value is an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|*]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS*.5&quot;&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>How many instances of each kind of persistent worker may be launched if you use the 'worker' strategy. May be specified as [name=value] to give a different value per mnemonic. The limit is based on worker keys, which are differentiated based on mnemonic, but also on startup flags and environment, so there can in some cases be more workers per mnemonic than this flag specifies. Takes an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|<em>]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS</em>.5&quot;. 'auto' calculates a reasonable default based on machine capacity. &quot;=value&quot; sets a default for unspecified mnemonics.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--worker_max_multiplex_instances"><code id="worker_max_multiplex_instances"><a href="#build-flag--worker_max_multiplex_instances">--worker_max_multiplex_instances</a>=&lt;[name=]value, where value is an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|*]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS*.5&quot;&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>How many WorkRequests a multiplex worker process may receive in parallel if you use the 'worker' strategy with --worker_multiplex. May be specified as [name=value] to give a different value per mnemonic. The limit is based on worker keys, which are differentiated based on mnemonic, but also on startup flags and environment, so there can in some cases be more workers per mnemonic than this flag specifies. Takes an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|<em>]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS</em>.5&quot;. 'auto' calculates a reasonable default based on machine capacity. &quot;=value&quot; sets a default for unspecified mnemonics.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--worker_multiplex"><code id="worker_multiplex"><a href="#build-flag--worker_multiplex">--[no]worker_multiplex</a></code> default: "true"</dt>
<dd>
<p>If enabled, workers will use multiplexing if they support it.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--worker_quit_after_build"><code id="worker_quit_after_build"><a href="#build-flag--worker_quit_after_build">--[no]worker_quit_after_build</a></code> default: "false"</dt>
<dd>
<p>If enabled, all workers quit after a build is done.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--worker_sandboxing"><code id="worker_sandboxing"><a href="#build-flag--worker_sandboxing">--[no]worker_sandboxing</a></code> default: "false"</dt>
<dd>
<p>If enabled, singleplex workers will run in a sandboxed environment. Singleplex workers are always sandboxed when running under the dynamic execution strategy, irrespective of this flag.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--worker_verbose"><code id="worker_verbose"><a href="#build-flag--worker_verbose">--[no]worker_verbose</a></code> default: "false"</dt>
<dd>
<p>If enabled, prints verbose messages when workers are started, shutdown, ...</p>
</dd>
</dl>
<dl>Options that control the output of the command:
<dt id="build-flag--build"><code id="build"><a href="#build-flag--build">--[no]build</a></code> default: "true"</dt>
<dd>
<p>Execute the build; this is the usual behaviour.
Specifying <code>--nobuild</code> causes the build to stop before executing the build
actions, returning zero if the package loading and analysis phases completed
successfully; this mode is useful for testing those phases.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--experimental_use_validation_aspect"><code id="experimental_use_validation_aspect"><a href="#build-flag--experimental_use_validation_aspect">--[no]experimental_use_validation_aspect</a></code> default: "false"</dt>
<dd>
<p>Whether to run validation actions using aspect (for parallelism with tests).</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--output_groups"><code id="output_groups"><a href="#build-flag--output_groups">--output_groups</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>A list of comma-separated output group names, each of which optionally prefixed by a <code>+</code>
or a <code>-</code>. A group prefixed by <code>+</code> is added to the default set of output groups,
while a group prefixed by <code>-</code> is removed from the default set. If at least one
group is not prefixed, the default set of output groups is omitted. For example,
<code>--output_groups=+foo,+bar</code> builds the union of the default set, foo, and bar,
while <code>--output_groups=foo,bar</code> overrides the default set such that only foo and
bar are built.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--run_validations"><code id="run_validations"><a href="#build-flag--run_validations">--[no]run_validations</a></code> default: "true"</dt>
<dd>
<p>Whether to run validation actions as part of the build. See <a href="https://bazel.build/extending/rules#validation_actions">Validation Actions</a>.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--serialized_frontier_profile"><code id="serialized_frontier_profile"><a href="#build-flag--serialized_frontier_profile">--serialized_frontier_profile</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Dump a profile of serialized frontier bytes. Specifies the output path.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
</dl>
<dl>Options that let the user configure the intended output, affecting its value, as opposed to its existence:
<dt id="build-flag--aspects"><code id="aspects"><a href="#build-flag--aspects">--aspects</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of aspects to be applied to top-level targets. In the list, if
aspect <code>some_aspect</code> specifies required aspect providers via
<code>required_aspect_providers</code>, <code>some_aspect</code> will run after
every aspect that was mentioned before it in the aspects list whose advertised
providers satisfy <code>some_aspect</code> required aspect providers. Moreover,
<code>some_aspect</code> will run after all its required aspects specified by
<code>requires</code> attribute.
<code>some_aspect</code> will then have access to the values of those aspects'
providers.
<code>{bzl-file-label}%{aspect_name}</code>, for example <code>//tools:my_def.bzl%my_aspect</code>, where
<code>my_aspect</code> is a top-level value from a file <code>tools/my_def.bzl</code>.</p>
</dd>
<dt id="build-flag--bep_maximum_open_remote_upload_files"><code id="bep_maximum_open_remote_upload_files"><a href="#build-flag--bep_maximum_open_remote_upload_files">--bep_maximum_open_remote_upload_files</a>=&lt;an integer&gt;</code> default: "-1"</dt>
<dd>
<p>Maximum number of open files allowed during BEP artifact upload.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--experimental_convenience_symlinks"><code id="experimental_convenience_symlinks"><a href="#build-flag--experimental_convenience_symlinks">--[no]experimental_convenience_symlinks</a></code> default: "normal"</dt>
<dd>
<p>This flag controls how the convenience symlinks (the symlinks that appear in the
workspace after the build) will be managed. Possible values:</p>
<ul>
<li><code>normal</code> (default): Each kind of convenience symlink will be created or deleted,
as determined by the build.</li>
<li><code>clean</code>: All symlinks will be unconditionally deleted.</li>
<li><code>ignore</code>: Symlinks will not be created or cleaned up.</li>
<li><code>log_only</code>: Generate log messages as if <code>normal</code> were passed, but don't actually
perform any filesystem operations (useful for tools).</li>
</ul>
<p>Note that only symlinks whose names are generated by the current value of
<code>--symlink_prefix</code> can be affected; if the prefix changes, any pre-existing
symlinks will be left alone.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--experimental_convenience_symlinks_bep_event"><code id="experimental_convenience_symlinks_bep_event"><a href="#build-flag--experimental_convenience_symlinks_bep_event">--[no]experimental_convenience_symlinks_bep_event</a></code> default: "true"</dt>
<dd>
<p>This flag controls whether or not we will post the build event
<code>ConvenienceSymlinksIdentified</code> to the Build Event Protocol. If the value is true,
the BEP will have an entry for <code>convenienceSymlinksIdentified</code>,
listing all of the convenience symlinks created in your workspace. If false, then
the <code>convenienceSymlinksIdentified</code> entry in the BEP will be empty.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--remote_download_all"><code id="remote_download_all"><a href="#build-flag--remote_download_all">--remote_download_all</a></code></dt>
<dd>
<p>Downloads all remote outputs to the local machine. This flag is an alias for --remote_download_outputs=all.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--remote_download_outputs">--remote_download_outputs=all</a></code>
</p><p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--remote_download_minimal"><code id="remote_download_minimal"><a href="#build-flag--remote_download_minimal">--remote_download_minimal</a></code></dt>
<dd>
<p>Does not download any remote build outputs to the local machine. This flag is an alias for --remote_download_outputs=minimal.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--remote_download_outputs">--remote_download_outputs=minimal</a></code>
</p><p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--remote_download_outputs"><code id="remote_download_outputs"><a href="#build-flag--remote_download_outputs">--remote_download_outputs</a>=&lt;all, minimal or toplevel&gt;</code> default: "toplevel"</dt>
<dd>
<p>If set to 'minimal' doesn't download any remote build outputs to the local machine, except the ones required by local actions. If set to 'toplevel' behaves like 'minimal' except that it also downloads outputs of top level targets to the local machine. Both options can significantly reduce build times if network bandwidth is a bottleneck.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--remote_download_symlink_template"><code id="remote_download_symlink_template"><a href="#build-flag--remote_download_symlink_template">--remote_download_symlink_template</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Instead of downloading remote build outputs to the local machine, create symbolic links. The target of the symbolic links can be specified in the form of a template string. This template string may contain {hash} and {size_bytes} that expand to the hash of the object and the size in bytes, respectively. These symbolic links may, for example, point to a FUSE file system that loads objects from the CAS on demand.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--remote_download_toplevel"><code id="remote_download_toplevel"><a href="#build-flag--remote_download_toplevel">--remote_download_toplevel</a></code></dt>
<dd>
<p>Only downloads remote outputs of top level targets to the local machine. This flag is an alias for --remote_download_outputs=toplevel.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--remote_download_outputs">--remote_download_outputs=toplevel</a></code>
</p><p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--symlink_prefix"><code id="symlink_prefix"><a href="#build-flag--symlink_prefix">--symlink_prefix</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The prefix that is prepended to any of the convenience symlinks that are created
after a build. If omitted, the default value is the name of the build tool
followed by a hyphen. If <code>/</code> is passed, then no symlinks are created and no
warning is emitted. Warning: the special functionality for <code>/</code> will be deprecated
soon; use <code>--experimental_convenience_symlinks=ignore</code> instead.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
</dl>
<dl>Options that affect how strictly Bazel enforces valid build inputs (rule definitions,  flag combinations, etc.):
<dt id="build-flag--experimental_docker_privileged"><code id="experimental_docker_privileged"><a href="#build-flag--experimental_docker_privileged">--[no]experimental_docker_privileged</a></code> default: "false"</dt>
<dd>
<p>If enabled, Bazel will pass the --privileged flag to 'docker run' when running actions. This might be required by your build, but it might also result in reduced hermeticity.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_sandboxfs_map_symlink_targets"><code id="experimental_sandboxfs_map_symlink_targets"><a href="#build-flag--experimental_sandboxfs_map_symlink_targets">--[no]experimental_sandboxfs_map_symlink_targets</a></code> default: "false"</dt>
<dd>
<p>No-op</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--sandbox_add_mount_pair"><code id="sandbox_add_mount_pair"><a href="#build-flag--sandbox_add_mount_pair">--sandbox_add_mount_pair</a>=&lt;a single path or a &#39;source:target&#39; pair&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Add additional path pair to mount in sandbox.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--sandbox_block_path"><code id="sandbox_block_path"><a href="#build-flag--sandbox_block_path">--sandbox_block_path</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>For sandboxed actions, disallow access to this path.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--sandbox_default_allow_network"><code id="sandbox_default_allow_network"><a href="#build-flag--sandbox_default_allow_network">--[no]sandbox_default_allow_network</a></code> default: "true"</dt>
<dd>
<p>Allow network access by default for actions; this may not work with all sandboxing implementations.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--sandbox_fake_hostname"><code id="sandbox_fake_hostname"><a href="#build-flag--sandbox_fake_hostname">--[no]sandbox_fake_hostname</a></code> default: "false"</dt>
<dd>
<p>Change the current hostname to 'localhost' for sandboxed actions.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--sandbox_fake_username"><code id="sandbox_fake_username"><a href="#build-flag--sandbox_fake_username">--[no]sandbox_fake_username</a></code> default: "false"</dt>
<dd>
<p>Change the current username to 'nobody' for sandboxed actions.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--sandbox_writable_path"><code id="sandbox_writable_path"><a href="#build-flag--sandbox_writable_path">--sandbox_writable_path</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>For sandboxed actions, make an existing directory writable in the sandbox (if supported by the sandboxing implementation, ignored otherwise).</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
</dl>
<dl>This option affects semantics of the Starlark language or the build API accessible to BUILD files, .bzl files, or WORKSPACE files.:
<dt id="build-flag--incompatible_config_setting_private_default_visibility"><code id="incompatible_config_setting_private_default_visibility"><a href="#build-flag--incompatible_config_setting_private_default_visibility">--[no]incompatible_config_setting_private_default_visibility</a></code> default: "false"</dt>
<dd>
<p>If incompatible_enforce_config_setting_visibility=false, this is a noop. Else, if this flag is false, any config_setting without an explicit visibility attribute is //visibility:public. If this flag is true, config_setting follows the same visibility logic as all other rules. See https://github.com/bazelbuild/bazel/issues/12933.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="build-flag--incompatible_enforce_config_setting_visibility"><code id="incompatible_enforce_config_setting_visibility"><a href="#build-flag--incompatible_enforce_config_setting_visibility">--[no]incompatible_enforce_config_setting_visibility</a></code> default: "true"</dt>
<dd>
<p>If true, enforce config_setting visibility restrictions. If false, every config_setting is visible to every target. See https://github.com/bazelbuild/bazel/issues/12932.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options that govern the behavior of the test environment or test runner:
<dt id="build-flag--check_tests_up_to_date"><code id="check_tests_up_to_date"><a href="#build-flag--check_tests_up_to_date">--[no]check_tests_up_to_date</a></code> default: "false"</dt>
<dd>
<p>Don't run tests, just check if they are up-to-date.  If all tests results are up-to-date, the testing completes successfully.  If any test needs to be built or executed, an error is reported and the testing fails.  This option implies --check_up_to_date behavior.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--flaky_test_attempts"><code id="flaky_test_attempts"><a href="#build-flag--flaky_test_attempts">--flaky_test_attempts</a>=&lt;a positive integer, the string &quot;default&quot;, or test_regex@attempts. This flag may be passed more than once&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Each test will be retried up to the specified number of times in case of any test failure. Tests that required more than one attempt to pass are marked as 'FLAKY' in the test summary. Normally the value specified is just an integer or the string 'default'. If an integer, then all tests will be run up to N times. If 'default', then only a single test attempt will be made for regular tests and three for tests marked explicitly as flaky by their rule (flaky=1 attribute). Alternate syntax: regex_filter@flaky_test_attempts. Where flaky_test_attempts is as above and regex_filter stands for a list of include and exclude regular expression patterns (Also see --runs_per_test). Example: --flaky_test_attempts=//foo/.<em>,-//foo/bar/.</em>@3 deflakes all tests in //foo/ except those under foo/bar three times. This option can be passed multiple times. The most recently passed argument that matches takes precedence. If nothing matches, behavior is as if 'default' above.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--local_test_jobs"><code id="local_test_jobs"><a href="#build-flag--local_test_jobs">--local_test_jobs</a>=&lt;an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|*]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS*.5&quot;&gt;</code> default: "auto"</dt>
<dd>
<p>The max number of local test jobs to run concurrently. Takes an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|<em>]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS</em>.5&quot;. 0 means local resources will limit the number of local test jobs to run concurrently instead. Setting this greater than the value for --jobs is ineffectual.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--test_keep_going"><code id="test_keep_going"><a href="#build-flag--test_keep_going">--[no]test_keep_going</a></code> default: "true"</dt>
<dd>
<p>When disabled, any non-passing test will cause the entire build to stop. By default all tests are run, even if some do not pass.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--test_strategy"><code id="test_strategy"><a href="#build-flag--test_strategy">--test_strategy</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Specifies which strategy to use when running tests.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--test_tmpdir"><code id="test_tmpdir"><a href="#build-flag--test_tmpdir">--test_tmpdir</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>Specifies the base temporary directory for 'bazel test' to use.</p>
</dd>
</dl>
<dl>Options that trigger optimizations of the build time:
<dt id="build-flag--cache_computed_file_digests"><code id="cache_computed_file_digests"><a href="#build-flag--cache_computed_file_digests">--cache_computed_file_digests</a>=&lt;a long integer&gt;</code> default: "50000"</dt>
<dd>
<p>If greater than 0, configures Bazel to cache file digests in memory based on their metadata instead of recomputing the digests from disk every time they are needed. Setting this to 0 ensures correctness because not all file changes can be noted from file metadata. When not 0, the number indicates the size of the cache as the number of file digests to be cached.</p>
</dd>
<dt id="build-flag--experimental_active_directories"><code id="experimental_active_directories"><a href="#build-flag--experimental_active_directories">--experimental_active_directories</a>=&lt;comma-separated list of options&gt;</code> default: ""</dt>
<dd>
<p>Active directories for Skyfocus and remote analysis caching. Specify as comma-separated workspace root-relative paths. This is a stateful flag. Defining one persists it for subsequent invocations, until it is redefined with a new set.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--experimental_cpu_load_scheduling"><code id="experimental_cpu_load_scheduling"><a href="#build-flag--experimental_cpu_load_scheduling">--[no]experimental_cpu_load_scheduling</a></code> default: "false"</dt>
<dd>
<p>Enables the experimental local execution scheduling based on CPU load, not estimation of actions one by one.  Experimental scheduling have showed the large benefit on a large local builds on a powerful machines with the large number of cores. Reccommended to use with --local_resources=cpu=HOST_CPUS</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_dynamic_ignore_local_signals"><code id="experimental_dynamic_ignore_local_signals"><a href="#build-flag--experimental_dynamic_ignore_local_signals">--experimental_dynamic_ignore_local_signals</a>=&lt;a comma-separated list of signal numbers&gt;</code> default: see description</dt>
<dd>
<p>Takes a list of OS signal numbers. If a local branch of dynamic execution gets killed with any of these signals, the remote branch will be allowed to finish instead. For persistent workers, this only affects signals that kill the worker process.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_enable_skyfocus"><code id="experimental_enable_skyfocus"><a href="#build-flag--experimental_enable_skyfocus">--[no]experimental_enable_skyfocus</a></code> default: "false"</dt>
<dd>
<p>If true, enable the use of --experimental_active_directories to reduce Bazel's memory footprint for incremental builds. This feature is known as Skyfocus.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--local_resources"><code id="local_resources"><a href="#build-flag--local_resources">--local_resources</a>=&lt;a named double, &#39;name=value&#39;, where value is an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|*]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS*.5&quot;&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Set the number of resources available to Bazel. Takes in an assignment to a float or HOST_RAM/HOST_CPUS, optionally followed by [-|<em>]&lt;float&gt; (eg. memory=HOST_RAM</em>.5 to use half the available RAM). Can be used multiple times to specify multiple types of resources. Bazel will limit concurrently running actions based on the available resources and the resources required. Tests can declare the amount of resources they need by using a tag of the &quot;resources:&lt;resource name&gt;:&lt;amount&gt;&quot; format.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
</dl>
<dl>Options that affect the verbosity, format or location of logging:
<dt id="build-flag--build_event_upload_max_retries"><code id="build_event_upload_max_retries"><a href="#build-flag--build_event_upload_max_retries">--build_event_upload_max_retries</a>=&lt;an integer&gt;</code> default: "4"</dt>
<dd>
<p>The maximum number of times Bazel should retry uploading a build event.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="build-flag--debug_spawn_scheduler"><code id="debug_spawn_scheduler"><a href="#build-flag--debug_spawn_scheduler">--[no]debug_spawn_scheduler</a></code> default: "false"</dt>
<dd>
</dd>
<dt id="build-flag--experimental_bep_target_summary"><code id="experimental_bep_target_summary"><a href="#build-flag--experimental_bep_target_summary">--[no]experimental_bep_target_summary</a></code> default: "false"</dt>
<dd>
<p>Whether to publish <code>TargetSummary</code> events.</p>
</dd>
<dt id="build-flag--experimental_build_event_expand_filesets"><code id="experimental_build_event_expand_filesets"><a href="#build-flag--experimental_build_event_expand_filesets">--[no]experimental_build_event_expand_filesets</a></code> default: "false"</dt>
<dd>
<p>If true, expand Filesets in the BEP when presenting output files.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--experimental_build_event_output_group_mode"><code id="experimental_build_event_output_group_mode"><a href="#build-flag--experimental_build_event_output_group_mode">--experimental_build_event_output_group_mode</a>=&lt;an output group name followed by an OutputGroupFileMode, e.g. default=both&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specify how an output group's files will be represented in <code>TargetComplete</code>/<code>AspectComplete</code>
BEP events. Values are an assignment of an output group name to one of
<code>NAMED_SET_OF_FILES_ONLY</code>, <code>INLINE_ONLY</code>, or <code>BOTH</code>. The default value is
<code>NAMED_SET_OF_FILES_ONLY</code>. If an output group is repeated, the final value to
appear is used. The default value sets the mode for coverage artifacts to BOTH:
<code>--experimental_build_event_output_group_mode=baseline.lcov=both</code></p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--experimental_build_event_upload_retry_minimum_delay"><code id="experimental_build_event_upload_retry_minimum_delay"><a href="#build-flag--experimental_build_event_upload_retry_minimum_delay">--experimental_build_event_upload_retry_minimum_delay</a>=&lt;An immutable length of time.&gt;</code> default: "1s"</dt>
<dd>
<p>Initial, minimum delay for exponential backoff retries when BEP upload fails. (exponent: 1.6)</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="build-flag--experimental_build_event_upload_strategy"><code id="experimental_build_event_upload_strategy"><a href="#build-flag--experimental_build_event_upload_strategy">--experimental_build_event_upload_strategy</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Selects how to upload artifacts referenced in the build event protocol. In Bazel
the valid options include <code>local</code> and <code>remote</code>. The default value is <code>local</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--experimental_docker_verbose"><code id="experimental_docker_verbose"><a href="#build-flag--experimental_docker_verbose">--[no]experimental_docker_verbose</a></code> default: "false"</dt>
<dd>
<p>If enabled, Bazel will print more verbose messages about the Docker sandbox strategy.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_frontier_violation_check"><code id="experimental_frontier_violation_check"><a href="#build-flag--experimental_frontier_violation_check">--experimental_frontier_violation_check</a>=&lt;strict, warn or disabled_for_testing&gt;</code> default: "strict"</dt>
<dd>
<p>Strategies to handle potential incorrectness from changes beyond the frontier (i.e. outside the active directories)</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="build-flag--experimental_frontier_violation_verbose"><code id="experimental_frontier_violation_verbose"><a href="#build-flag--experimental_frontier_violation_verbose">--[no]experimental_frontier_violation_verbose</a></code> default: "false"</dt>
<dd>
<p>If true, Bazel will print instructions for fixing Skycache violations</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="build-flag--experimental_materialize_param_files_directly"><code id="experimental_materialize_param_files_directly"><a href="#build-flag--experimental_materialize_param_files_directly">--[no]experimental_materialize_param_files_directly</a></code> default: "false"</dt>
<dd>
<p>If materializing param files, do so with direct writes to disk.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_run_bep_event_include_residue"><code id="experimental_run_bep_event_include_residue"><a href="#build-flag--experimental_run_bep_event_include_residue">--[no]experimental_run_bep_event_include_residue</a></code> default: "false"</dt>
<dd>
<p>Whether to include the command-line residue in run build events which could contain the residue. By default, the residue is not included in run command build events that could contain the residue.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--experimental_skyfocus_dump_keys"><code id="experimental_skyfocus_dump_keys"><a href="#build-flag--experimental_skyfocus_dump_keys">--experimental_skyfocus_dump_keys</a>=&lt;none, count or verbose&gt;</code> default: "none"</dt>
<dd>
<p>For debugging Skyfocus. Dump the focused SkyKeys (roots, leafs, focused deps, focused rdeps).</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="build-flag--experimental_skyfocus_dump_post_gc_stats"><code id="experimental_skyfocus_dump_post_gc_stats"><a href="#build-flag--experimental_skyfocus_dump_post_gc_stats">--[no]experimental_skyfocus_dump_post_gc_stats</a></code> default: "false"</dt>
<dd>
<p>For debugging Skyfocus. If enabled, trigger manual GC before/after focusing to report heap sizes reductions. This will increase the Skyfocus latency.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="build-flag--experimental_stream_log_file_uploads"><code id="experimental_stream_log_file_uploads"><a href="#build-flag--experimental_stream_log_file_uploads">--[no]experimental_stream_log_file_uploads</a></code> default: "false"</dt>
<dd>
<p>Stream log file uploads directly to the remote storage rather than writing them to disk.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--explain"><code id="explain"><a href="#build-flag--explain">--explain</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>Causes the build system to explain each executed step of the build. The explanation is written to the specified log file.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--ignore_unsupported_sandboxing"><code id="ignore_unsupported_sandboxing"><a href="#build-flag--ignore_unsupported_sandboxing">--[no]ignore_unsupported_sandboxing</a></code> default: "false"</dt>
<dd>
<p>Do not print a warning when sandboxed execution is not supported on this system.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="build-flag--legacy_important_outputs"><code id="legacy_important_outputs"><a href="#build-flag--legacy_important_outputs">--[no]legacy_important_outputs</a></code> default: "false"</dt>
<dd>
<p>Use this to suppress generation of the legacy <code>important_outputs</code> field in the
<code>TargetComplete</code> event. <code>important_outputs</code> are required for Bazel to ResultStore/BTX
integration.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--materialize_param_files"><code id="materialize_param_files"><a href="#build-flag--materialize_param_files">--[no]materialize_param_files</a></code> default: "false"</dt>
<dd>
<p>Writes intermediate parameter files to output tree even when using remote action execution or caching. Useful when debugging actions. This is implied by --subcommands and --verbose_failures.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--max_config_changes_to_show"><code id="max_config_changes_to_show"><a href="#build-flag--max_config_changes_to_show">--max_config_changes_to_show</a>=&lt;an integer&gt;</code> default: "3"</dt>
<dd>
<p>When discarding the analysis cache due to a change in the build options, displays up to the given number of changed option names. If the number given is -1, all changed options will be displayed.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="build-flag--max_test_output_bytes"><code id="max_test_output_bytes"><a href="#build-flag--max_test_output_bytes">--max_test_output_bytes</a>=&lt;an integer&gt;</code> default: "-1"</dt>
<dd>
<p>Specifies maximum per-test-log size that can be emitted when --test_output is 'errors' or 'all'. Useful for avoiding overwhelming the output with excessively noisy test output. The test header is included in the log size. Negative values imply no limit. Output is all or nothing.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>, <a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--output_filter"><code id="output_filter"><a href="#build-flag--output_filter">--output_filter</a>=&lt;a valid Java regular expression&gt;</code> default: see description</dt>
<dd>
<p>Only shows warnings and action outputs for rules with a name matching the provided regular expression.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--progress_report_interval"><code id="progress_report_interval"><a href="#build-flag--progress_report_interval">--progress_report_interval</a>=&lt;an integer in 0-3600 range&gt;</code> default: "0"</dt>
<dd>
<p>The number of seconds to wait between reports on still running jobs. The
default value 0 means the first report will be printed after 10
seconds, then 30 seconds and after that progress is reported once every minute.
When <code>--curses</code> is enabled, progress is reported every second.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--remote_analysis_json_log"><code id="remote_analysis_json_log"><a href="#build-flag--remote_analysis_json_log">--remote_analysis_json_log</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>If set, a JSON file is written to this location that contains a detailed log of the behavior of remote analysis caching. It's interpreted as a path relative to the current working directory.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="build-flag--remote_print_execution_messages"><code id="remote_print_execution_messages"><a href="#build-flag--remote_print_execution_messages">--remote_print_execution_messages</a>=&lt;failure, success or all&gt;</code> default: "failure"</dt>
<dd>
<p>Choose when to print remote execution messages. Valid values are <code>failure</code>, to print only on failures, <code>success</code> to print only on successes and <code>all</code> to print always.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="build-flag--sandbox_debug"><code id="sandbox_debug"><a href="#build-flag--sandbox_debug">--[no]sandbox_debug</a></code> default: "false"</dt>
<dd>
<p>Enables debugging features for the sandboxing feature. This includes two things: first, the sandbox root contents are left untouched after a build; and second, prints extra debugging information on execution. This can help developers of Bazel or Starlark rules with debugging failures due to missing input files, etc.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="build-flag--show_result"><code id="show_result"><a href="#build-flag--show_result">--show_result</a>=&lt;an integer&gt;</code> default: "1"</dt>
<dd>
<p>Show the results of the build. For each target, state whether or not it was brought
up-to-date, and if so, a list of output files that were built.  The printed files
are convenient strings for copy+pasting to the shell, to execute them.</p>
<p>This option requires an integer argument, which is the threshold number of targets
above which result information is not printed. Thus zero causes suppression of
the message and <code>MAX_INT</code> causes printing of the result to occur always. The
default is one.</p>
<p>If nothing was built for a target its results may be omitted to keep the output
under the threshold.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--subcommands"><code id="subcommands"><a href="#build-flag--subcommands">--[no]subcommands</a></code> [<code>-s</code>] default: "false"</dt>
<dd>
<p>Display the subcommands executed during a build. Related flags: --execution_log_json_file, --execution_log_binary_file (for logging subcommands to a file in a tool-friendly format).</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="build-flag--test_output"><code id="test_output"><a href="#build-flag--test_output">--test_output</a>=&lt;summary, errors, all or streamed&gt;</code> default: "summary"</dt>
<dd>
<p>Specifies desired output mode. Valid values are 'summary' to output only test status summary, 'errors' to also print test logs for failed tests, 'all' to print logs for all tests and 'streamed' to output logs for all tests in real time (this will force tests to be executed locally one at a time regardless of --test_strategy value).</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>, <a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--test_summary"><code id="test_summary"><a href="#build-flag--test_summary">--test_summary</a>=&lt;short, terse, detailed, none or testcase&gt;</code> default: "short"</dt>
<dd>
<p>Specifies the desired format of the test summary. Valid values are 'short' to print information only about tests executed, 'terse', to print information only about unsuccessful tests that were run, 'detailed' to print detailed information about failed test cases, 'testcase' to print summary in test case resolution, do not print detailed information about failed test cases and 'none' to omit the summary.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="build-flag--verbose_failures"><code id="verbose_failures"><a href="#build-flag--verbose_failures">--[no]verbose_failures</a></code> default: "false"</dt>
<dd>
<p>If a command fails, print out the full command line.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
</dl>
<dl>Options specifying or altering a generic input to a Bazel command that does not fall into other categories.:
<dt id="build-flag--aspects_parameters"><code id="aspects_parameters"><a href="#build-flag--aspects_parameters">--aspects_parameters</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the values of the command-line aspects parameters. Each parameter value is
specified via <code>&amp;lt;param_name&amp;gt;=&amp;lt;param_value&amp;gt;</code>, for example <code>my_param=my_val</code> where
<code>my_param</code> is a parameter of some aspect in <code>--aspects</code> list or required by an
aspect in the list. This option can be used multiple times. However, it is not
allowed to assign values to the same parameter more than once.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="build-flag--target_pattern_file"><code id="target_pattern_file"><a href="#build-flag--target_pattern_file">--target_pattern_file</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>If set, build will read patterns from the file named here, rather than on the command line. It is an error to specify a file here as well as command-line patterns.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
</dl>
<dl>Remote caching and execution options:
<dt id="build-flag--experimental_circuit_breaker_strategy"><code id="experimental_circuit_breaker_strategy"><a href="#build-flag--experimental_circuit_breaker_strategy">--experimental_circuit_breaker_strategy</a>=&lt;failure&gt;</code> default: see description</dt>
<dd>
<p>Specifies the strategy for the circuit breaker to use. Available strategies are &quot;failure&quot;. On invalid value for the option the behavior same as the option is not set.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_remote_cache_compression_threshold"><code id="experimental_remote_cache_compression_threshold"><a href="#build-flag--experimental_remote_cache_compression_threshold">--experimental_remote_cache_compression_threshold</a>=&lt;an integer&gt;</code> default: "100"</dt>
<dd>
<p>The minimum blob size required to compress/decompress with zstd. Ineffectual unless --remote_cache_compression is set.</p>
</dd>
<dt id="build-flag--experimental_remote_cache_eviction_retries"><code id="experimental_remote_cache_eviction_retries"><a href="#build-flag--experimental_remote_cache_eviction_retries">--experimental_remote_cache_eviction_retries</a>=&lt;an integer&gt;</code> default: "5"</dt>
<dd>
<p>The maximum number of attempts to retry if the build encountered a transient remote cache error that would otherwise fail the build. Applies for example when artifacts are evicted from the remote cache, or in certain cache failure conditions. A new invocation id will be generated for each attempt.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_remote_cache_lease_extension"><code id="experimental_remote_cache_lease_extension"><a href="#build-flag--experimental_remote_cache_lease_extension">--[no]experimental_remote_cache_lease_extension</a></code> default: "false"</dt>
<dd>
<p>If set to true, Bazel will extend the lease for outputs of remote actions during the build by sending <code>FindMissingBlobs</code> calls periodically to remote cache. The frequency is based on the value of <code>--experimental_remote_cache_ttl</code>.</p>
</dd>
<dt id="build-flag--experimental_remote_cache_ttl"><code id="experimental_remote_cache_ttl"><a href="#build-flag--experimental_remote_cache_ttl">--experimental_remote_cache_ttl</a>=&lt;An immutable length of time.&gt;</code> default: "3h"</dt>
<dd>
<p>The guaranteed minimal TTL of blobs in the remote cache after their digests are recently referenced e.g. by an ActionResult or FindMissingBlobs. Bazel does several optimizations based on the blobs' TTL e.g. doesn't repeatedly call GetActionResult in an incremental build. The value should be set slightly less than the real TTL since there is a gap between when the server returns the digests and when Bazel receives them.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_remote_capture_corrupted_outputs"><code id="experimental_remote_capture_corrupted_outputs"><a href="#build-flag--experimental_remote_capture_corrupted_outputs">--experimental_remote_capture_corrupted_outputs</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>A path to a directory where the corrupted outputs will be captured to.</p>
</dd>
<dt id="build-flag--experimental_remote_discard_merkle_trees"><code id="experimental_remote_discard_merkle_trees"><a href="#build-flag--experimental_remote_discard_merkle_trees">--[no]experimental_remote_discard_merkle_trees</a></code> default: "true"</dt>
<dd>
<p>If set to true, discard in-memory copies of the input root's Merkle tree and associated input mappings during calls to GetActionResult() and Execute(). This reduces memory usage significantly, but does require Bazel to recompute them upon remote cache misses and retries.</p>
</dd>
<dt id="build-flag--experimental_remote_downloader"><code id="experimental_remote_downloader"><a href="#build-flag--experimental_remote_downloader">--experimental_remote_downloader</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>A Remote Asset API endpoint URI, to be used as a remote download proxy. The supported schemas are grpc, grpcs (grpc with TLS enabled) and unix (local UNIX sockets). If no schema is provided Bazel will default to grpcs. See: https://github.com/bazelbuild/remote-apis/blob/master/build/bazel/remote/asset/v1/remote_asset.proto</p>
</dd>
<dt id="build-flag--experimental_remote_downloader_local_fallback"><code id="experimental_remote_downloader_local_fallback"><a href="#build-flag--experimental_remote_downloader_local_fallback">--[no]experimental_remote_downloader_local_fallback</a></code> default: "false"</dt>
<dd>
<p>Whether to fall back to the local downloader if remote downloader fails.</p>
</dd>
<dt id="build-flag--experimental_remote_downloader_propagate_credentials"><code id="experimental_remote_downloader_propagate_credentials"><a href="#build-flag--experimental_remote_downloader_propagate_credentials">--[no]experimental_remote_downloader_propagate_credentials</a></code> default: "false"</dt>
<dd>
<p>Whether to propagate credentials from netrc and credential helper to the remote downloader server. The server implementation needs to support the new <code>http_header_url:&amp;lt;url-index&amp;gt;:&amp;lt;header-key&amp;gt;</code> qualifier where the <code>&amp;lt;url-index&amp;gt;</code> is a 0-based position of the URL inside the FetchBlobRequest's <code>uris</code> field. The URL-specific headers should take precedence over the global headers.</p>
</dd>
<dt id="build-flag--experimental_remote_execution_keepalive"><code id="experimental_remote_execution_keepalive"><a href="#build-flag--experimental_remote_execution_keepalive">--[no]experimental_remote_execution_keepalive</a></code> default: "false"</dt>
<dd>
<p>Whether to use keepalive for remote execution calls.</p>
</dd>
<dt id="build-flag--experimental_remote_failure_rate_threshold"><code id="experimental_remote_failure_rate_threshold"><a href="#build-flag--experimental_remote_failure_rate_threshold">--experimental_remote_failure_rate_threshold</a>=&lt;an integer in 0-100 range&gt;</code> default: "10"</dt>
<dd>
<p>Sets the allowed number of failure rate in percentage for a specific time window after which it stops calling to the remote cache/executor. By default the value is 10. Setting this to 0 means no limitation.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_remote_failure_window_interval"><code id="experimental_remote_failure_window_interval"><a href="#build-flag--experimental_remote_failure_window_interval">--experimental_remote_failure_window_interval</a>=&lt;An immutable length of time.&gt;</code> default: "60s"</dt>
<dd>
<p>The interval in which the failure rate of the remote requests are computed. On zero or negative value the failure duration is computed the whole duration of the execution.Following units can be used: Days (d), hours (h), minutes (m), seconds (s), and milliseconds (ms). If the unit is omitted, the value is interpreted as seconds.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--experimental_remote_mark_tool_inputs"><code id="experimental_remote_mark_tool_inputs"><a href="#build-flag--experimental_remote_mark_tool_inputs">--[no]experimental_remote_mark_tool_inputs</a></code> default: "false"</dt>
<dd>
<p>If set to true, Bazel will mark inputs as tool inputs for the remote executor. This can be used to implement remote persistent workers.</p>
</dd>
<dt id="build-flag--experimental_remote_output_service"><code id="experimental_remote_output_service"><a href="#build-flag--experimental_remote_output_service">--experimental_remote_output_service</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>HOST or HOST:PORT of a remote output service endpoint. The supported schemas are grpc, grpcs (grpc with TLS enabled) and unix (local UNIX sockets). If no schema is provided Bazel will default to grpcs. Specify grpc:// or unix: schema to disable TLS.</p>
</dd>
<dt id="build-flag--experimental_remote_output_service_output_path_prefix"><code id="experimental_remote_output_service_output_path_prefix"><a href="#build-flag--experimental_remote_output_service_output_path_prefix">--experimental_remote_output_service_output_path_prefix</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The path under which the contents of output directories managed by the --experimental_remote_output_service are placed. The actual output directory used by a build will be a descendant of this path and determined by the output service.</p>
</dd>
<dt id="build-flag--experimental_remote_require_cached"><code id="experimental_remote_require_cached"><a href="#build-flag--experimental_remote_require_cached">--[no]experimental_remote_require_cached</a></code> default: "false"</dt>
<dd>
<p>If set to true, enforce that all actions that can run remotely are cached, or else fail the build. This is useful to troubleshoot non-determinism issues as it allows checking whether actions that should be cached are actually cached without spuriously injecting new results into the cache.</p>
</dd>
<dt id="build-flag--experimental_remote_scrubbing_config"><code id="experimental_remote_scrubbing_config"><a href="#build-flag--experimental_remote_scrubbing_config">--experimental_remote_scrubbing_config</a>=&lt;Converts to a Scrubber&gt;</code> default: see description</dt>
<dd>
<p>Enables remote cache key scrubbing with the supplied configuration file, which must be a protocol buffer in text format (see src/main/protobuf/remote_scrubbing.proto).</p>
<p>This feature is intended to facilitate sharing a remote/disk cache between actions executing on different platforms but targeting the same platform. It should be used with extreme care, as improper settings may cause accidental sharing of cache entries and result in incorrect builds.</p>
<p>Scrubbing does not affect how an action is executed, only how its remote/disk cache key is computed for the purpose of retrieving or storing an action result. Scrubbed actions are incompatible with remote execution, and will always be executed locally instead.</p>
<p>Modifying the scrubbing configuration does not invalidate outputs present in the local filesystem or internal caches; a clean build is required to reexecute affected actions.</p>
<p>In order to successfully use this feature, you likely want to set a custom --host_platform together with --experimental_platform_in_output_dir (to normalize output prefixes) and --incompatible_strict_action_env (to normalize environment variables).</p>
</dd>
<dt id="build-flag--guard_against_concurrent_changes"><code id="guard_against_concurrent_changes"><a href="#build-flag--guard_against_concurrent_changes">--[no]guard_against_concurrent_changes</a></code> default: "lite"</dt>
<dd>
<p>Set this to 'full' to enable checking the ctime of all input files of an action before uploading it to a remote cache. There may be cases where the Linux kernel delays writing of files, which could cause false positives. The default is 'lite', which only checks source files in the main repository. Setting this to 'off' disables all checks. This is not recommended, as the cache may be polluted when a source file is changed while an action that takes it as an input is executing.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="build-flag--remote_accept_cached"><code id="remote_accept_cached"><a href="#build-flag--remote_accept_cached">--[no]remote_accept_cached</a></code> default: "true"</dt>
<dd>
<p>Whether to accept remotely cached action results.</p>
</dd>
<dt id="build-flag--remote_build_event_upload"><code id="remote_build_event_upload"><a href="#build-flag--remote_build_event_upload">--remote_build_event_upload</a>=&lt;all or minimal&gt;</code> default: "minimal"</dt>
<dd>
<p>If set to 'all', all local outputs referenced by BEP are uploaded to remote cache.
If set to 'minimal', local outputs referenced by BEP are not uploaded to the remote cache, except for files that are important to the consumers of BEP (e.g. test logs and timing profile). bytestream:// scheme is always used for the uri of files even if they are missing from remote cache.
Default to 'minimal'.</p>
</dd>
<dt id="build-flag--remote_bytestream_uri_prefix"><code id="remote_bytestream_uri_prefix"><a href="#build-flag--remote_bytestream_uri_prefix">--remote_bytestream_uri_prefix</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The hostname and instance name to be used in bytestream:// URIs that are written into build event streams. This option can be set when builds are performed using a proxy, which causes the values of --remote_executor and --remote_instance_name to no longer correspond to the canonical name of the remote execution service. When not set, it will default to &quot;${hostname}/${instance_name}&quot;.</p>
</dd>
<dt id="build-flag--remote_cache"><code id="remote_cache"><a href="#build-flag--remote_cache">--remote_cache</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>A URI of a caching endpoint. The supported schemas are http, https, grpc, grpcs (grpc with TLS enabled) and unix (local UNIX sockets). If no schema is provided Bazel will default to grpcs. Specify grpc://, http:// or unix: schema to disable TLS. See https://bazel.build/remote/caching</p>
</dd>
<dt id="build-flag--remote_cache_async"><code id="remote_cache_async"><a href="#build-flag--remote_cache_async">--[no]remote_cache_async</a></code> default: "true"</dt>
<dd>
<p>If true, uploading of action results to a disk or remote cache will happen in the background instead of blocking the completion of an action. Some actions are incompatible with background uploads, and may still block even when this flag is set.</p>
</dd>
<dt id="build-flag--remote_cache_compression"><code id="remote_cache_compression"><a href="#build-flag--remote_cache_compression">--[no]remote_cache_compression</a></code> default: "false"</dt>
<dd>
<p>If enabled, compress/decompress cache blobs with zstd when their size is at least --experimental_remote_cache_compression_threshold.</p>
</dd>
<dt id="build-flag--remote_cache_header"><code id="remote_cache_header"><a href="#build-flag--remote_cache_header">--remote_cache_header</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specify a header that will be included in cache requests: --remote_cache_header=Name=Value. Multiple headers can be passed by specifying the flag multiple times. Multiple values for the same name will be converted to a comma-separated list.</p>
</dd>
<dt id="build-flag--remote_default_exec_properties"><code id="remote_default_exec_properties"><a href="#build-flag--remote_default_exec_properties">--remote_default_exec_properties</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Set the default exec properties to be used as the remote execution platform if an execution platform does not already set exec_properties.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--remote_default_platform_properties"><code id="remote_default_platform_properties"><a href="#build-flag--remote_default_platform_properties">--remote_default_platform_properties</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Set the default platform properties to be set for the remote execution API, if the execution platform does not already set remote_execution_properties. This value will also be used if the host platform is selected as the execution platform for remote execution.</p>
</dd>
<dt id="build-flag--remote_download_regex"><code id="remote_download_regex"><a href="#build-flag--remote_download_regex">--remote_download_regex</a>=&lt;a valid Java regular expression&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Force remote build outputs whose path matches this pattern to be downloaded, irrespective of --remote_download_outputs. Multiple patterns may be specified by repeating this flag.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="build-flag--remote_downloader_header"><code id="remote_downloader_header"><a href="#build-flag--remote_downloader_header">--remote_downloader_header</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specify a header that will be included in remote downloader requests: --remote_downloader_header=Name=Value. Multiple headers can be passed by specifying the flag multiple times. Multiple values for the same name will be converted to a comma-separated list.</p>
</dd>
<dt id="build-flag--remote_exec_header"><code id="remote_exec_header"><a href="#build-flag--remote_exec_header">--remote_exec_header</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specify a header that will be included in execution requests: --remote_exec_header=Name=Value. Multiple headers can be passed by specifying the flag multiple times. Multiple values for the same name will be converted to a comma-separated list.</p>
</dd>
<dt id="build-flag--remote_execution_priority"><code id="remote_execution_priority"><a href="#build-flag--remote_execution_priority">--remote_execution_priority</a>=&lt;an integer&gt;</code> default: "0"</dt>
<dd>
<p>The relative priority of actions to be executed remotely. The semantics of the particular priority values are server-dependent.</p>
</dd>
<dt id="build-flag--remote_executor"><code id="remote_executor"><a href="#build-flag--remote_executor">--remote_executor</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>HOST or HOST:PORT of a remote execution endpoint. The supported schemas are grpc, grpcs (grpc with TLS enabled) and unix (local UNIX sockets). If no schema is provided Bazel will default to grpcs. Specify grpc:// or unix: schema to disable TLS.</p>
</dd>
<dt id="build-flag--remote_grpc_log"><code id="remote_grpc_log"><a href="#build-flag--remote_grpc_log">--remote_grpc_log</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>If specified, a path to a file to log gRPC call related details. This log consists of a sequence of serialized com.google.devtools.build.lib.remote.logging.RemoteExecutionLog.LogEntry protobufs with each message prefixed by a varint denoting the size of the following serialized protobuf message, as performed by the method LogEntry.writeDelimitedTo(OutputStream).</p>
</dd>
<dt id="build-flag--remote_header"><code id="remote_header"><a href="#build-flag--remote_header">--remote_header</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specify a header that will be included in requests: --remote_header=Name=Value. Multiple headers can be passed by specifying the flag multiple times. Multiple values for the same name will be converted to a comma-separated list.</p>
</dd>
<dt id="build-flag--remote_instance_name"><code id="remote_instance_name"><a href="#build-flag--remote_instance_name">--remote_instance_name</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Value to pass as instance_name in the remote execution API.</p>
</dd>
<dt id="build-flag--remote_local_fallback"><code id="remote_local_fallback"><a href="#build-flag--remote_local_fallback">--[no]remote_local_fallback</a></code> default: "false"</dt>
<dd>
<p>Whether to fall back to standalone local execution strategy if remote execution fails.</p>
</dd>
<dt id="build-flag--remote_local_fallback_strategy"><code id="remote_local_fallback_strategy"><a href="#build-flag--remote_local_fallback_strategy">--remote_local_fallback_strategy</a>=&lt;a string&gt;</code> default: "local"</dt>
<dd>
<p>Deprecated. See https://github.com/bazelbuild/bazel/issues/7480 for details.</p>
</dd>
<dt id="build-flag--remote_max_connections"><code id="remote_max_connections"><a href="#build-flag--remote_max_connections">--remote_max_connections</a>=&lt;an integer&gt;</code> default: "100"</dt>
<dd>
<p>Limit the max number of concurrent connections to remote cache/executor. By default the value is 100. Setting this to 0 means no limitation.
For HTTP remote cache, one TCP connection could handle one request at one time, so Bazel could make up to --remote_max_connections concurrent requests.
For gRPC remote cache/executor, one gRPC channel could usually handle 100+ concurrent requests, so Bazel could make around <code>--remote_max_connections * 100</code> concurrent requests.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="build-flag--remote_proxy"><code id="remote_proxy"><a href="#build-flag--remote_proxy">--remote_proxy</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Connect to the remote cache through a proxy. Currently this flag can only be used to configure a Unix domain socket (unix:/path/to/socket).</p>
</dd>
<dt id="build-flag--remote_result_cache_priority"><code id="remote_result_cache_priority"><a href="#build-flag--remote_result_cache_priority">--remote_result_cache_priority</a>=&lt;an integer&gt;</code> default: "0"</dt>
<dd>
<p>The relative priority of remote actions to be stored in remote cache. The semantics of the particular priority values are server-dependent.</p>
</dd>
<dt id="build-flag--remote_retries"><code id="remote_retries"><a href="#build-flag--remote_retries">--remote_retries</a>=&lt;an integer&gt;</code> default: "5"</dt>
<dd>
<p>The maximum number of attempts to retry a transient error. If set to 0, retries are disabled.</p>
</dd>
<dt id="build-flag--remote_retry_max_delay"><code id="remote_retry_max_delay"><a href="#build-flag--remote_retry_max_delay">--remote_retry_max_delay</a>=&lt;An immutable length of time.&gt;</code> default: "5s"</dt>
<dd>
<p>The maximum backoff delay between remote retry attempts. Following units can be used: Days (d), hours (h), minutes (m), seconds (s), and milliseconds (ms). If the unit is omitted, the value is interpreted as seconds.</p>
</dd>
<dt id="build-flag--remote_timeout"><code id="remote_timeout"><a href="#build-flag--remote_timeout">--remote_timeout</a>=&lt;An immutable length of time.&gt;</code> default: "60s"</dt>
<dd>
<p>The maximum amount of time to wait for remote execution and cache calls. For the REST cache, this is both the connect and the read timeout. Following units can be used: Days (d), hours (h), minutes (m), seconds (s), and milliseconds (ms). If the unit is omitted, the value is interpreted as seconds.</p>
</dd>
<dt id="build-flag--remote_upload_local_results"><code id="remote_upload_local_results"><a href="#build-flag--remote_upload_local_results">--[no]remote_upload_local_results</a></code> default: "true"</dt>
<dd>
<p>Whether to upload locally executed action results to the remote cache if the remote cache supports it and the user is authorized to do so.</p>
</dd>
<dt id="build-flag--remote_verify_downloads"><code id="remote_verify_downloads"><a href="#build-flag--remote_verify_downloads">--[no]remote_verify_downloads</a></code> default: "true"</dt>
<dd>
<p>If set to true, Bazel will compute the hash sum of all remote downloads and  discard the remotely cached values if they don't match the expected value.</p>
</dd>
</dl>
<dl>Miscellaneous options, not otherwise categorized.:
<dt id="build-flag--allow_analysis_cache_discard"><code id="allow_analysis_cache_discard"><a href="#build-flag--allow_analysis_cache_discard">--[no]allow_analysis_cache_discard</a></code> default: "true"</dt>
<dd>
<p>If discarding the analysis cache due to a change in the build system, setting this
option to false will cause bazel to exit, rather than continuing with the build.
This option has no effect when <code>--discard_analysis_cache</code> is also set.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="build-flag--auto_output_filter"><code id="auto_output_filter"><a href="#build-flag--auto_output_filter">--auto_output_filter</a>=&lt;none, all, packages or subpackages&gt;</code> default: "none"</dt>
<dd>
<p>If --output_filter is not specified, then the value for this option is used create a filter automatically. Allowed values are 'none' (filter nothing / show everything), 'all' (filter everything / show nothing), 'packages' (include output from rules in packages mentioned on the Blaze command line), and 'subpackages' (like 'packages', but also include subpackages). For the 'packages' and 'subpackages' values //java/foo and //javatests/foo are treated as one package)'.</p>
</dd>
<dt id="build-flag--build_manual_tests"><code id="build_manual_tests"><a href="#build-flag--build_manual_tests">--[no]build_manual_tests</a></code> default: "false"</dt>
<dd>
<p>Forces test targets tagged 'manual' to be built. 'manual' tests are excluded from processing. This option forces them to be built (but not executed).</p>
</dd>
<dt id="build-flag--build_tag_filters"><code id="build_tag_filters"><a href="#build-flag--build_tag_filters">--build_tag_filters</a>=&lt;comma-separated list of options&gt;</code> default: ""</dt>
<dd>
<p>Specifies a comma-separated list of tags. Each tag can be optionally preceded with '-' to specify excluded tags. Only those targets will be built that contain at least one included tag and do not contain any excluded tags. This option does not affect the set of tests executed with the 'test' command; those are be governed by the test filtering options, for example '--test_tag_filters'</p>
</dd>
<dt id="build-flag--build_tests_only"><code id="build_tests_only"><a href="#build-flag--build_tests_only">--[no]build_tests_only</a></code> default: "false"</dt>
<dd>
<p>If specified, only *_test and test_suite rules will be built and other targets specified on the command line will be ignored. By default everything that was requested will be built.</p>
</dd>
<dt id="build-flag--combined_report"><code id="combined_report"><a href="#build-flag--combined_report">--combined_report</a>=&lt;none or lcov&gt;</code> default: "lcov"</dt>
<dd>
<p>Specifies desired cumulative coverage report type. At this point only LCOV is supported.</p>
</dd>
<dt id="build-flag--compile_one_dependency"><code id="compile_one_dependency"><a href="#build-flag--compile_one_dependency">--[no]compile_one_dependency</a></code> default: "false"</dt>
<dd>
<p>Compile a single dependency of the argument files. This is useful for syntax checking source files in IDEs, for example, by rebuilding a single target that depends on the source file to detect errors as early as possible in the edit/build/test cycle. This argument affects the way all non-flag arguments are interpreted; instead of being targets to build they are source filenames.  For each source filename an arbitrary target that depends on it will be built.</p>
</dd>
<dt id="build-flag--deleted_packages"><code id="deleted_packages"><a href="#build-flag--deleted_packages">--deleted_packages</a>=&lt;comma-separated list of package names&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>A comma-separated list of names of packages which the build system will consider non-existent, even if they are visible somewhere on the package path.
Use this option when deleting a subpackage 'x/y' of an existing package 'x'.  For example, after deleting x/y/BUILD in your client, the build system may complain if it encounters a label '//x:y/z' if that is still provided by another package_path entry.  Specifying --deleted_packages x/y avoids this problem.</p>
</dd>
<dt id="build-flag--discard_analysis_cache"><code id="discard_analysis_cache"><a href="#build-flag--discard_analysis_cache">--[no]discard_analysis_cache</a></code> default: "false"</dt>
<dd>
<p>Discard the analysis cache immediately after the analysis phase completes. Reduces memory usage by ~10%, but makes further incremental builds slower.</p>
</dd>
<dt id="build-flag--disk_cache"><code id="disk_cache"><a href="#build-flag--disk_cache">--disk_cache</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>A path to a directory where Bazel can read and write actions and action outputs. If the directory does not exist, it will be created.</p>
</dd>
<dt id="build-flag--embed_label"><code id="embed_label"><a href="#build-flag--embed_label">--embed_label</a>=&lt;a one-line string&gt;</code> default: ""</dt>
<dd>
<p>Embed source control revision or release label in binary</p>
</dd>
<dt id="build-flag--execution_log_binary_file"><code id="execution_log_binary_file"><a href="#build-flag--execution_log_binary_file">--execution_log_binary_file</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>Log the executed spawns into this file as length-delimited SpawnExec protos, according to src/main/protobuf/spawn.proto. Prefer --execution_log_compact_file, which is significantly smaller and cheaper to produce. Related flags: --execution_log_compact_file (compact format; mutually exclusive), --execution_log_json_file (text JSON format; mutually exclusive), --execution_log_sort (whether to sort the execution log), --subcommands (for displaying subcommands in terminal output).</p>
</dd>
<dt id="build-flag--execution_log_compact_file"><code id="execution_log_compact_file"><a href="#build-flag--execution_log_compact_file">--execution_log_compact_file</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>Log the executed spawns into this file as length-delimited ExecLogEntry protos, according to src/main/protobuf/spawn.proto. The entire file is zstd compressed. Related flags: --execution_log_binary_file (binary protobuf format; mutually exclusive), --execution_log_json_file (text JSON format; mutually exclusive), --subcommands (for displaying subcommands in terminal output).</p>
</dd>
<dt id="build-flag--execution_log_json_file"><code id="execution_log_json_file"><a href="#build-flag--execution_log_json_file">--execution_log_json_file</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>Log the executed spawns into this file as newline-delimited JSON representations of SpawnExec protos, according to src/main/protobuf/spawn.proto. Prefer --execution_log_compact_file, which is significantly smaller and cheaper to produce. Related flags: --execution_log_compact_file (compact format; mutually exclusive), --execution_log_binary_file (binary protobuf format; mutually exclusive), --execution_log_sort (whether to sort the execution log), --subcommands (for displaying subcommands in terminal output).</p>
</dd>
<dt id="build-flag--execution_log_sort"><code id="execution_log_sort"><a href="#build-flag--execution_log_sort">--[no]execution_log_sort</a></code> default: "true"</dt>
<dd>
<p>Whether to sort the execution log, making it easier to compare logs across invocations. Set to false to avoid potentially significant CPU and memory usage at the end of the invocation, at the cost of producing the log in nondeterministic execution order. Only applies to the binary and JSON formats; the compact format is never sorted.</p>
</dd>
<dt id="build-flag--expand_test_suites"><code id="expand_test_suites"><a href="#build-flag--expand_test_suites">--[no]expand_test_suites</a></code> default: "true"</dt>
<dd>
<p>Expand test_suite targets into their constituent tests before analysis. When this flag is turned on (the default), negative target patterns will apply to the tests belonging to the test suite, otherwise they will not. Turning off this flag is useful when top-level aspects are applied at command line: then they can analyze test_suite targets.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="build-flag--experimental_disk_cache_gc_idle_delay"><code id="experimental_disk_cache_gc_idle_delay"><a href="#build-flag--experimental_disk_cache_gc_idle_delay">--experimental_disk_cache_gc_idle_delay</a>=&lt;An immutable length of time.&gt;</code> default: "5m"</dt>
<dd>
<p>How long the server must remain idle before a garbage collection of the disk cache occurs. To specify the garbage collection policy, set --experimental_disk_cache_gc_max_size and/or --experimental_disk_cache_gc_max_age.</p>
</dd>
<dt id="build-flag--experimental_disk_cache_gc_max_age"><code id="experimental_disk_cache_gc_max_age"><a href="#build-flag--experimental_disk_cache_gc_max_age">--experimental_disk_cache_gc_max_age</a>=&lt;An immutable length of time.&gt;</code> default: "0"</dt>
<dd>
<p>If set to a positive value, the disk cache will be periodically garbage collected to remove entries older than this age. If set in conjunction with --experimental_disk_cache_gc_max_size, both criteria are applied. Garbage collection occurrs in the background once the server has become idle, as determined by the --experimental_disk_cache_gc_idle_delay flag.</p>
</dd>
<dt id="build-flag--experimental_disk_cache_gc_max_size"><code id="experimental_disk_cache_gc_max_size"><a href="#build-flag--experimental_disk_cache_gc_max_size">--experimental_disk_cache_gc_max_size</a>=&lt;a size in bytes, optionally followed by a K, M, G or T multiplier&gt;</code> default: "0"</dt>
<dd>
<p>If set to a positive value, the disk cache will be periodically garbage collected to stay under this size. If set in conjunction with --experimental_disk_cache_gc_max_age, both criteria are applied. Garbage collection occurrs in the background once the server has become idle, as determined by the --experimental_disk_cache_gc_idle_delay flag.</p>
</dd>
<dt id="build-flag--experimental_extra_action_filter"><code id="experimental_extra_action_filter"><a href="#build-flag--experimental_extra_action_filter">--experimental_extra_action_filter</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths&gt;</code> default: ""</dt>
<dd>
<p>Deprecated in favor of aspects. Filters set of targets to schedule extra_actions for.</p>
</dd>
<dt id="build-flag--experimental_extra_action_top_level_only"><code id="experimental_extra_action_top_level_only"><a href="#build-flag--experimental_extra_action_top_level_only">--[no]experimental_extra_action_top_level_only</a></code> default: "false"</dt>
<dd>
<p>Deprecated in favor of aspects. Only schedules extra_actions for top level targets.</p>
</dd>
<dt id="build-flag--experimental_spawn_scheduler"><code id="experimental_spawn_scheduler"><a href="#build-flag--experimental_spawn_scheduler">--experimental_spawn_scheduler</a></code></dt>
<dd>
<p>Enable dynamic execution by running actions locally and remotely in parallel. Bazel spawns each action locally and remotely and picks the one that completes first. If an action supports workers, the local action will be run in the persistent worker mode. To enable dynamic execution for an individual action mnemonic, use the <code>--internal_spawn_scheduler</code> and <code>--strategy=&amp;lt;mnemonic&amp;gt;=dynamic</code> flags instead.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_spawn_scheduler">--internal_spawn_scheduler</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--spawn_strategy">--spawn_strategy=dynamic</a></code>
</p></dd>
<dt id="build-flag--fetch"><code id="fetch"><a href="#build-flag--fetch">--[no]fetch</a></code> default: "true"</dt>
<dd>
<p>Allows the command to fetch external dependencies. If set to false, the command will utilize any cached version of the dependency, and if none exists, the command will result in failure.</p>
</dd>
<dt id="build-flag--local_termination_grace_seconds"><code id="local_termination_grace_seconds"><a href="#build-flag--local_termination_grace_seconds">--local_termination_grace_seconds</a>=&lt;an integer&gt;</code> default: "15"</dt>
<dd>
<p>Time to wait between terminating a local process due to timeout and forcefully shutting it down.</p>
</dd>
<dt id="build-flag--package_path"><code id="package_path"><a href="#build-flag--package_path">--package_path</a>=&lt;colon-separated list of options&gt;</code> default: "%workspace%"</dt>
<dd>
<p>A colon-separated list of where to look for packages. Elements beginning with '%workspace%' are relative to the enclosing workspace. If omitted or empty, the default is the output of 'bazel info default-package-path'.</p>
</dd>
<dt id="build-flag--show_loading_progress"><code id="show_loading_progress"><a href="#build-flag--show_loading_progress">--[no]show_loading_progress</a></code> default: "true"</dt>
<dd>
<p>If enabled, causes Bazel to print &quot;Loading package:&quot; messages.</p>
</dd>
<dt id="build-flag--test_lang_filters"><code id="test_lang_filters"><a href="#build-flag--test_lang_filters">--test_lang_filters</a>=&lt;comma-separated list of options&gt;</code> default: ""</dt>
<dd>
<p>Specifies a comma-separated list of test languages. Each language can be optionally preceded with '-' to specify excluded languages. Only those test targets will be found that are written in the specified languages. The name used for each language should be the same as the language prefix in the *_test rule, e.g. one of 'cc', 'java', 'py', etc. This option affects --build_tests_only behavior and the test command.</p>
</dd>
<dt id="build-flag--test_size_filters"><code id="test_size_filters"><a href="#build-flag--test_size_filters">--test_size_filters</a>=&lt;comma-separated list of values: small, medium, large, or enormous&gt;</code> default: ""</dt>
<dd>
<p>Specifies a comma-separated list of test sizes. Each size can be optionally preceded with '-' to specify excluded sizes. Only those test targets will be found that contain at least one included size and do not contain any excluded sizes. This option affects --build_tests_only behavior and the test command.</p>
</dd>
<dt id="build-flag--test_tag_filters"><code id="test_tag_filters"><a href="#build-flag--test_tag_filters">--test_tag_filters</a>=&lt;comma-separated list of options&gt;</code> default: ""</dt>
<dd>
<p>Specifies a comma-separated list of test tags. Each tag can be optionally preceded with '-' to specify excluded tags. Only those test targets will be found that contain at least one included tag and do not contain any excluded tags. This option affects --build_tests_only behavior and the test command.</p>
</dd>
<dt id="build-flag--test_timeout_filters"><code id="test_timeout_filters"><a href="#build-flag--test_timeout_filters">--test_timeout_filters</a>=&lt;comma-separated list of values: short, moderate, long, or eternal&gt;</code> default: ""</dt>
<dd>
<p>Specifies a comma-separated list of test timeouts. Each timeout can be optionally preceded with '-' to specify excluded timeouts. Only those test targets will be found that contain at least one included timeout and do not contain any excluded timeouts. This option affects --build_tests_only behavior and the test command.</p>
</dd>
<dt id="build-flag--workspace_status_command"><code id="workspace_status_command"><a href="#build-flag--workspace_status_command">--workspace_status_command</a>=&lt;path&gt;</code> default: ""</dt>
<dd>
<p>A command invoked at the beginning of the build to provide status
information about the workspace in the form of key/value pairs.
See the User's Manual for the full specification. Also see
<a href="https://github.com/bazelbuild/bazel/blob/master/tools/buildstamp/get_workspace_status"><code>tools/buildstamp/get_workspace_status</code></a> for an example.</p>
</dd>
</dl>

<dl>Options that control build execution:
<dt id="flag--experimental_persistent_aar_extractor"><code><a href="#flag--experimental_persistent_aar_extractor">--[no]experimental_persistent_aar_extractor</a></code> default: "false"</dt>
<dd>
<p>Enable persistent aar extractor by using workers.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_remotable_source_manifests"><code><a href="#flag--experimental_remotable_source_manifests">--[no]experimental_remotable_source_manifests</a></code> default: "false"</dt>
<dd>
<p>Whether to make source manifest actions remotable</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_split_coverage_postprocessing"><code><a href="#flag--experimental_split_coverage_postprocessing">--[no]experimental_split_coverage_postprocessing</a></code> default: "false"</dt>
<dd>
<p>If true, then Bazel will run coverage postprocessing for test in a new spawn.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_strict_fileset_output"><code><a href="#flag--experimental_strict_fileset_output">--[no]experimental_strict_fileset_output</a></code> default: "false"</dt>
<dd>
<p>If this option is enabled, filesets will treat all output artifacts as regular files. They will not traverse directories or be sensitive to symlinks.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--incompatible_modify_execution_info_additive"><code><a href="#flag--incompatible_modify_execution_info_additive">--[no]incompatible_modify_execution_info_additive</a></code> default: "true"</dt>
<dd>
<p>When enabled, passing multiple <code>--modify_execution_info</code> flags is additive.
When disabled, only the last flag is taken into account.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--modify_execution_info"><code><a href="#flag--modify_execution_info">--modify_execution_info</a>=&lt;regex=[+-]key,regex=[+-]key,...&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Add or remove keys from an action's execution info based on action mnemonic.
Applies only to actions which support execution info. Many common actions
support execution info, e.g. Genrule, CppCompile, Javac, StarlarkAction,
TestRunner. When specifying multiple values, order matters because
many regexes may apply to the same mnemonic.</p>
<p>Syntax: <code>regex=[+-]key,regex=[+-]key,...</code>.</p>
<p>Examples:</p>
<ul>
<li><code>.*=+x,.*=-y,.*=+z</code> adds <code>x</code> and <code>z</code> to, and removes <code>y</code> from, the execution info for all actions.</li>
<li><code>Genrule=+requires-x</code> adds <code>requires-x</code> to the execution info for all Genrule actions.</li>
<li><code>(?!Genrule).*=-requires-x</code> removes <code>requires-x</code> from the execution info for all non-Genrule actions.</li>
</ul>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--persistent_android_dex_desugar"><code><a href="#flag--persistent_android_dex_desugar">--persistent_android_dex_desugar</a></code></dt>
<dd>
<p>Enable persistent Android dex and desugar actions by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_android_dex_desugar">--internal_persistent_android_dex_desugar</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=Desugar=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=DexBuilder=worker</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_android_resource_processor"><code><a href="#flag--persistent_android_resource_processor">--persistent_android_resource_processor</a></code></dt>
<dd>
<p>Enable persistent Android resource processor by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_busybox_tools">--internal_persistent_busybox_tools</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AaptPackage=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceParser=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceValidator=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceCompiler=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=RClassGenerator=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceLink=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidAapt2=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidAssetMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidCompiledResourceMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=ManifestMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidManifestMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=Aapt2Optimize=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AARGenerator=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=ProcessDatabinding=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=GenerateDataBindingBaseClasses=worker</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_multiplex_android_dex_desugar"><code><a href="#flag--persistent_multiplex_android_dex_desugar">--persistent_multiplex_android_dex_desugar</a></code></dt>
<dd>
<p>Enable persistent multiplexed Android dex and desugar actions by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_android_dex_desugar">--persistent_android_dex_desugar</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_multiplex_android_dex_desugar">--internal_persistent_multiplex_android_dex_desugar</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_multiplex_android_resource_processor"><code><a href="#flag--persistent_multiplex_android_resource_processor">--persistent_multiplex_android_resource_processor</a></code></dt>
<dd>
<p>Enable persistent multiplexed Android resource processor by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_android_resource_processor">--persistent_android_resource_processor</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AaptPackage=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceParser=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceValidator=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceCompiler=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=RClassGenerator=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceLink=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidAapt2=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidAssetMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidCompiledResourceMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=ManifestMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidManifestMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=Aapt2Optimize=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AARGenerator=+supports-multiplex-workers</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_multiplex_android_tools"><code><a href="#flag--persistent_multiplex_android_tools">--persistent_multiplex_android_tools</a></code></dt>
<dd>
<p>Enable persistent and multiplexed Android tools (dexing, desugaring, resource processing).</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_multiplex_busybox_tools">--internal_persistent_multiplex_busybox_tools</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_multiplex_android_resource_processor">--persistent_multiplex_android_resource_processor</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_multiplex_android_dex_desugar">--persistent_multiplex_android_dex_desugar</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--use_target_platform_for_tests"><code><a href="#flag--use_target_platform_for_tests">--[no]use_target_platform_for_tests</a></code> default: "false"</dt>
<dd>
<p>If true, use the target platform for running tests rather than the test exec group.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
</dl>
<dl>Options that configure the toolchain used for action execution:
<dt id="flag--android_compiler"><code><a href="#flag--android_compiler">--android_compiler</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The Android target compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--android_manifest_merger"><code><a href="#flag--android_manifest_merger">--android_manifest_merger</a>=&lt;legacy, android or force_android&gt;</code> default: "android"</dt>
<dd>
<p>Selects the manifest merger to use for android_binary rules. Flag to help the transition to the Android manifest merger from the legacy merger.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--android_platforms"><code><a href="#flag--android_platforms">--android_platforms</a>=&lt;a build target label&gt;</code> default: ""</dt>
<dd>
<p>Sets the platforms that android_binary targets use. If multiple platforms are specified, then the binary is a fat APKs, which contains native binaries for each specified target platform.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--cc_output_directory_tag"><code><a href="#flag--cc_output_directory_tag">--cc_output_directory_tag</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Specifies a suffix to be added to the configuration directory.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--compiler"><code><a href="#flag--compiler">--compiler</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The C++ compiler to use for compiling the target.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--coverage_output_generator"><code><a href="#flag--coverage_output_generator">--coverage_output_generator</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/test:lcov_merger"</dt>
<dd>
<p>Location of the binary that is used to postprocess raw coverage reports. This must
be a binary target. Defaults to <code>@bazel_tools//tools/test:lcov_merger</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--coverage_report_generator"><code><a href="#flag--coverage_report_generator">--coverage_report_generator</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/test:coverage_report_generator"</dt>
<dd>
<p>Location of the binary that is used to generate coverage reports. This must
be a binary target. Defaults to <code>@bazel_tools//tools/test:coverage_report_generator</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--coverage_support"><code><a href="#flag--coverage_support">--coverage_support</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/test:coverage_support"</dt>
<dd>
<p>Location of support files that are required on the inputs of every test action
that collects code coverage. Defaults to <code>//tools/test:coverage_support</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--custom_malloc"><code><a href="#flag--custom_malloc">--custom_malloc</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies a custom malloc implementation. This setting overrides malloc attributes in build rules.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--experimental_include_xcode_execution_requirements"><code><a href="#flag--experimental_include_xcode_execution_requirements">--[no]experimental_include_xcode_execution_requirements</a></code> default: "false"</dt>
<dd>
<p>If set, add a &quot;requires-xcode:{version}&quot; execution requirement to every Xcode action.  If the Xcode version has a hyphenated label,  also add a &quot;requires-xcode-label:{version_label}&quot; execution requirement.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_prefer_mutual_xcode"><code><a href="#flag--experimental_prefer_mutual_xcode">--[no]experimental_prefer_mutual_xcode</a></code> default: "true"</dt>
<dd>
<p>If true, use the most recent Xcode that is available both locally and remotely. If false, or if there are no mutual available versions, use the local Xcode version selected via xcode-select.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--extra_execution_platforms"><code><a href="#flag--extra_execution_platforms">--extra_execution_platforms</a>=&lt;comma-separated list of options&gt;</code> default: ""</dt>
<dd>
<p>The platforms that are available as execution platforms to run actions.
Platforms can be specified by exact target, or as a target pattern.
These platforms will be considered before those declared in the <code>WORKSPACE</code> file by
<code>register_execution_platforms()</code>. This option may only be set once; later
instances will override earlier flag settings.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--extra_toolchains"><code><a href="#flag--extra_toolchains">--extra_toolchains</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The toolchain rules to be considered during toolchain resolution.
Toolchains can be specified by exact target, or as a target pattern.
These toolchains will be considered before those declared in the <code>WORKSPACE</code> file
by <code>register_toolchains()</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--grte_top"><code><a href="#flag--grte_top">--grte_top</a>=&lt;a label&gt;</code> default: see description</dt>
<dd>
<p>A label to a checked-in libc library. The default value is selected by the crosstool toolchain, and you almost never need to override it.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_compiler"><code><a href="#flag--host_compiler">--host_compiler</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>No-op flag. Will be removed in a future release.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--host_grte_top"><code><a href="#flag--host_grte_top">--host_grte_top</a>=&lt;a label&gt;</code> default: see description</dt>
<dd>
<p>If specified, this setting overrides the libc top-level directory (--grte_top) for the exec configuration.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_platform"><code><a href="#flag--host_platform">--host_platform</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools:host_platform"</dt>
<dd>
<p>The label of a platform rule that describes the host system.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--incompatible_bazel_test_exec_run_under"><code><a href="#flag--incompatible_bazel_test_exec_run_under">--[no]incompatible_bazel_test_exec_run_under</a></code> default: "true"</dt>
<dd>
<p>If enabled, <code>bazel test --run_under=//:runner</code> builds <code>//:runner</code> in the exec
configuration. If disabled, it builds <code>//:runner</code> in the target configuration.
Bazel executes tests on exec machines, so the former is more correct. This
doesn't affect <code>bazel run</code>, which always builds <code>--run_under=//foo</code> in the
target configuration.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_builtin_objc_strip_action"><code><a href="#flag--incompatible_builtin_objc_strip_action">--[no]incompatible_builtin_objc_strip_action</a></code> default: "true"</dt>
<dd>
<p>Whether to emit a strip action as part of objc linking.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_dont_enable_host_nonhost_crosstool_features"><code><a href="#flag--incompatible_dont_enable_host_nonhost_crosstool_features">--[no]incompatible_dont_enable_host_nonhost_crosstool_features</a></code> default: "true"</dt>
<dd>
<p>If true, Bazel will not enable 'host' and 'nonhost' features in the c++ toolchain (see https://github.com/bazelbuild/bazel/issues/7407 for more information).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_enable_apple_toolchain_resolution"><code><a href="#flag--incompatible_enable_apple_toolchain_resolution">--[no]incompatible_enable_apple_toolchain_resolution</a></code> default: "false"</dt>
<dd>
<p>Use toolchain resolution to select the Apple SDK for apple rules (Starlark and native)</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_remove_legacy_whole_archive"><code><a href="#flag--incompatible_remove_legacy_whole_archive">--[no]incompatible_remove_legacy_whole_archive</a></code> default: "true"</dt>
<dd>
<p>If true, Bazel will not link library dependencies as whole archive by default (see https://github.com/bazelbuild/bazel/issues/7362 for migration instructions).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_strip_executable_safely"><code><a href="#flag--incompatible_strip_executable_safely">--[no]incompatible_strip_executable_safely</a></code> default: "false"</dt>
<dd>
<p>If true, strip action for executables will use flag -x, which does not break dynamic symbol resolution.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--interface_shared_objects"><code><a href="#flag--interface_shared_objects">--[no]interface_shared_objects</a></code> default: "true"</dt>
<dd>
<p>Use interface shared objects if supported by the toolchain. All ELF toolchains currently support this setting.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ios_sdk_version"><code><a href="#flag--ios_sdk_version">--ios_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the iOS SDK to use to build iOS applications. If unspecified, uses the default iOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--macos_sdk_version"><code><a href="#flag--macos_sdk_version">--macos_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the macOS SDK to use to build macOS applications. If unspecified, uses the default macOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--minimum_os_version"><code><a href="#flag--minimum_os_version">--minimum_os_version</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The minimum OS version which your compilation targets.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--platform_mappings"><code><a href="#flag--platform_mappings">--platform_mappings</a>=&lt;a main workspace-relative path&gt;</code> default: ""</dt>
<dd>
<p>The location of a mapping file that describes which platform to use if none is set or
which flags to set when a platform already exists. Must be relative to the main
workspace root. Defaults to <code>platform_mappings</code> (a file directly under the
workspace root).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--platforms"><code><a href="#flag--platforms">--platforms</a>=&lt;a build target label&gt;</code> default: ""</dt>
<dd>
<p>The labels of the platform rules describing the target platforms for the current command.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--python_path"><code><a href="#flag--python_path">--python_path</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The absolute path of the Python interpreter invoked to run Python targets on the
target platform. Deprecated; disabled by <code>--incompatible_use_python_toolchains</code>.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--tvos_sdk_version"><code><a href="#flag--tvos_sdk_version">--tvos_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the tvOS SDK to use to build tvOS applications. If unspecified, uses the default tvOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--use_platforms_in_apple_crosstool_transition"><code><a href="#flag--use_platforms_in_apple_crosstool_transition">--[no]use_platforms_in_apple_crosstool_transition</a></code> default: "false"</dt>
<dd>
<p>Makes apple_crosstool_transition fall back to using the value of <code>--platforms</code> flag instead of legacy <code>--cpu</code> when needed.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--watchos_sdk_version"><code><a href="#flag--watchos_sdk_version">--watchos_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the watchOS SDK to use to build watchOS applications. If unspecified, uses the default watchOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--xcode_version"><code><a href="#flag--xcode_version">--xcode_version</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>If specified, uses Xcode of the given version for relevant build actions. If unspecified, uses the executor default version of Xcode.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--xcode_version_config"><code><a href="#flag--xcode_version_config">--xcode_version_config</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/cpp:host_xcodes"</dt>
<dd>
<p>The label of the xcode_config rule to be used for selecting the Xcode version in the build configuration.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
</dl>
<dl>Options that control the output of the command:
<dt id="flag--apple_generate_dsym"><code><a href="#flag--apple_generate_dsym">--[no]apple_generate_dsym</a></code> default: "false"</dt>
<dd>
<p>Whether to generate debug symbol(.dSYM) file(s).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--build_runfile_links"><code><a href="#flag--build_runfile_links">--[no]build_runfile_links</a></code> default: "true"</dt>
<dd>
<p>If true, build runfiles symlink forests for all targets.  If false, write them only when required by a local action, test or run command.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--build_runfile_manifests"><code><a href="#flag--build_runfile_manifests">--[no]build_runfile_manifests</a></code> default: "true"</dt>
<dd>
<p>If true, write runfiles manifests for all targets. If false, omit them. Local tests will fail to run when false.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--build_test_dwp"><code><a href="#flag--build_test_dwp">--[no]build_test_dwp</a></code> default: "false"</dt>
<dd>
<p>If enabled, when building C++ tests statically and with fission the .dwp file  for the test binary will be automatically built as well.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cc_proto_library_header_suffixes"><code><a href="#flag--cc_proto_library_header_suffixes">--cc_proto_library_header_suffixes</a>=&lt;comma-separated set of options&gt;</code> default: ".pb.h"</dt>
<dd>
<p>Sets the suffixes of header files that a cc_proto_library creates.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--cc_proto_library_source_suffixes"><code><a href="#flag--cc_proto_library_source_suffixes">--cc_proto_library_source_suffixes</a>=&lt;comma-separated set of options&gt;</code> default: ".pb.cc"</dt>
<dd>
<p>Sets the suffixes of source files that a cc_proto_library creates.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--experimental_proto_descriptor_sets_include_source_info"><code><a href="#flag--experimental_proto_descriptor_sets_include_source_info">--[no]experimental_proto_descriptor_sets_include_source_info</a></code> default: "false"</dt>
<dd>
<p>Run extra actions for alternative Java api versions in a proto_library.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_save_feature_state"><code><a href="#flag--experimental_save_feature_state">--[no]experimental_save_feature_state</a></code> default: "false"</dt>
<dd>
<p>Save the state of enabled and requested feautres as an output of compilation.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--fission"><code><a href="#flag--fission">--fission</a>=&lt;a set of compilation modes&gt;</code> default: "no"</dt>
<dd>
<p>Specifies which compilation modes use fission for C++ compilations and links.  May be any combination of {'fastbuild', 'dbg', 'opt'} or the special values 'yes'  to enable all modes and 'no' to disable all modes.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--incompatible_always_include_files_in_data"><code><a href="#flag--incompatible_always_include_files_in_data">--[no]incompatible_always_include_files_in_data</a></code> default: "true"</dt>
<dd>
<p>If true, native rules add <code>DefaultInfo.files</code> of data dependencies to their runfiles,
which matches the recommended behavior for Starlark rules (<a href="https://bazel.build/extending/rules#runfiles_features_to_avoid">runfiles features to avoid</a>).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_compact_repo_mapping_manifest"><code><a href="#flag--incompatible_compact_repo_mapping_manifest">--[no]incompatible_compact_repo_mapping_manifest</a></code> default: "false"</dt>
<dd>
<p>If enabled, the <code>{binary}.repo_mapping</code> file emits a module extension's repo mapping
only once instead of once for each repo generated by the extension that
contributes runfiles.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_disable_select_on"><code><a href="#flag--incompatible_disable_select_on">--incompatible_disable_select_on</a>=&lt;comma-separated set of options&gt;</code> default: ""</dt>
<dd>
<p>List of flags for which the use in <code>select()</code> is disabled.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--incompatible_filegroup_runfiles_for_data"><code><a href="#flag--incompatible_filegroup_runfiles_for_data">--[no]incompatible_filegroup_runfiles_for_data</a></code> default: "true"</dt>
<dd>
<p>If true, runfiles of targets listed in the srcs attribute are available to targets that consume the filegroup as a data dependency.</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--objc_generate_linkmap"><code><a href="#flag--objc_generate_linkmap">--[no]objc_generate_linkmap</a></code> default: "false"</dt>
<dd>
<p>Specifies whether to generate a linkmap file.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--save_temps"><code><a href="#flag--save_temps">--[no]save_temps</a></code> default: "false"</dt>
<dd>
<p>If set, temporary outputs from gcc will be saved.  These include .s files (assembler code), .i files (preprocessed C) and .ii files (preprocessed C++).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
</dl>
<dl>Options that let the user configure the intended output, affecting its value, as opposed to its existence:
<dt id="flag--action_env"><code><a href="#flag--action_env">--action_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the set of environment variables available to actions with target
configuration. Variables can be either specified by <code>name</code>, in which case
the value will be taken from the invocation environment, by the <code>name=value</code>
pair which sets the value independent of the invocation environment, or by
<code>=name</code>, which unsets the variable of that name. This option can be used
multiple times; for options given for the same variable, the latest wins,
options for different variables accumulate.</p>
<p>Note that unless <code>--incompatible_repo_env_ignores_action_env</code> is true, all <code>name=value</code>
pairs will be available to repository rules.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--allowed_cpu_values"><code><a href="#flag--allowed_cpu_values">--allowed_cpu_values</a>=&lt;comma-separated set of options&gt;</code> default: ""</dt>
<dd>
<p>Allowed values for the <code>--cpu</code> flag.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--android_databinding_use_androidx"><code><a href="#flag--android_databinding_use_androidx">--[no]android_databinding_use_androidx</a></code> default: "true"</dt>
<dd>
<p>Generate AndroidX-compatible data-binding files. This is only used with databinding v2. This flag is a no-op.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--android_databinding_use_v3_4_args"><code><a href="#flag--android_databinding_use_v3_4_args">--[no]android_databinding_use_v3_4_args</a></code> default: "true"</dt>
<dd>
<p>Use android databinding v2 with 3.4.0 argument. This flag is a no-op.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--android_dynamic_mode"><code><a href="#flag--android_dynamic_mode">--android_dynamic_mode</a>=&lt;off, default or fully&gt;</code> default: "off"</dt>
<dd>
<p>Determines whether C++ deps of Android rules will be linked dynamically when a cc_binary does not explicitly create a shared library. 'default' means bazel will choose whether to link dynamically.  'fully' means all libraries will be linked dynamically. 'off' means that all libraries will be linked in mostly static mode.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--android_manifest_merger_order"><code><a href="#flag--android_manifest_merger_order">--android_manifest_merger_order</a>=&lt;alphabetical, alphabetical_by_configuration or dependency&gt;</code> default: "alphabetical"</dt>
<dd>
<p>Sets the order of manifests passed to the manifest merger for Android binaries. ALPHABETICAL means manifests are sorted by path relative to the execroot. ALPHABETICAL_BY_CONFIGURATION means manifests are sorted by paths relative to the configuration directory within the output directory. DEPENDENCY means manifests are ordered with each library's manifest coming before the manifests of its dependencies.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--android_resource_shrinking"><code><a href="#flag--android_resource_shrinking">--[no]android_resource_shrinking</a></code> default: "false"</dt>
<dd>
<p>Enables resource shrinking for android_binary APKs that use ProGuard.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--build_python_zip"><code><a href="#flag--build_python_zip">--[no]build_python_zip</a></code> default: "auto"</dt>
<dd>
<p>Build python executable zip; on on Windows, off on other platforms</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--catalyst_cpus"><code><a href="#flag--catalyst_cpus">--catalyst_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple Catalyst binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--collect_code_coverage"><code><a href="#flag--collect_code_coverage">--[no]collect_code_coverage</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will instrument code (using offline instrumentation where
possible) and will collect coverage information during tests. Only targets that
match <code>--instrumentation_filter</code> will be affected. Usually this option should
not be specified directly - <code>bazel coverage</code> command should be used instead.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--compilation_mode"><code><a href="#flag--compilation_mode">--compilation_mode</a>=&lt;fastbuild, dbg or opt&gt;</code> [<code>-c</code>] default: "fastbuild"</dt>
<dd>
<p>Specify the mode the binary will be built in. Values: <code>fastbuild</code>, <code>dbg</code>, <code>opt</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--conlyopt"><code><a href="#flag--conlyopt">--conlyopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to gcc when compiling C source files.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--copt"><code><a href="#flag--copt">--copt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to gcc.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cpu"><code><a href="#flag--cpu">--cpu</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Deprecated: this flag is not used internally by Blaze although there are legacy platform
mappings to allow for backwards compatibility. Do not use this flag, instead use
<code>--platforms</code> with an appropriate platform definition.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cs_fdo_absolute_path"><code><a href="#flag--cs_fdo_absolute_path">--cs_fdo_absolute_path</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Use CSFDO profile information to optimize compilation. Specify the absolute path name of the zip file containing the profile file, a raw or an indexed LLVM profile file.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cs_fdo_instrument"><code><a href="#flag--cs_fdo_instrument">--cs_fdo_instrument</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Generate binaries with context sensitive FDO instrumentation. With Clang/LLVM compiler, it also accepts the directory name under which the raw profile file(s) will be dumped at runtime.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cs_fdo_profile"><code><a href="#flag--cs_fdo_profile">--cs_fdo_profile</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The cs_fdo_profile representing the context sensitive profile to be used for optimization.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cxxopt"><code><a href="#flag--cxxopt">--cxxopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to gcc when compiling C++ source files.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--define"><code><a href="#flag--define">--define</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Each <code>--define</code> option specifies an assignment for a build variable.
In case of multiple values for a variable, the last one wins.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--dynamic_mode"><code><a href="#flag--dynamic_mode">--dynamic_mode</a>=&lt;off, default or fully&gt;</code> default: "default"</dt>
<dd>
<p>Determines whether C++ binaries will be linked dynamically.  'default' means Bazel will choose whether to link dynamically.  'fully' means all libraries will be linked dynamically. 'off' means that all libraries will be linked in mostly static mode.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--enable_propeller_optimize_absolute_paths"><code><a href="#flag--enable_propeller_optimize_absolute_paths">--[no]enable_propeller_optimize_absolute_paths</a></code> default: "true"</dt>
<dd>
<p>If set, any use of absolute paths for propeller optimize will raise an error.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--enable_remaining_fdo_absolute_paths"><code><a href="#flag--enable_remaining_fdo_absolute_paths">--[no]enable_remaining_fdo_absolute_paths</a></code> default: "true"</dt>
<dd>
<p>If set, any use of absolute paths for FDO will raise an error.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--enable_runfiles"><code><a href="#flag--enable_runfiles">--[no]enable_runfiles</a></code> default: "auto"</dt>
<dd>
<p>Enable runfiles symlink tree; By default, it's off on Windows, on on other platforms.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--exec_aspects"><code><a href="#flag--exec_aspects">--exec_aspects</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of aspects to be applied to exec-configured targets, regardless of whether or not they are top-level targets. This is an experimental feature and is subject to change.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--experimental_action_listener"><code><a href="#flag--experimental_action_listener">--experimental_action_listener</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Deprecated in favor of aspects. Use <code>action_listener</code> to attach an <code>extra_action</code> to
existing build actions.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_compress_java_resources"><code><a href="#flag--experimental_android_compress_java_resources">--[no]experimental_android_compress_java_resources</a></code> default: "false"</dt>
<dd>
<p>Compress Java resources in APKs</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_databinding_v2"><code><a href="#flag--experimental_android_databinding_v2">--[no]experimental_android_databinding_v2</a></code> default: "true"</dt>
<dd>
<p>Use android databinding v2. This flag is a no-op.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_resource_shrinking"><code><a href="#flag--experimental_android_resource_shrinking">--[no]experimental_android_resource_shrinking</a></code> default: "false"</dt>
<dd>
<p>Enables resource shrinking for android_binary APKs that use ProGuard.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_rewrite_dexes_with_rex"><code><a href="#flag--experimental_android_rewrite_dexes_with_rex">--[no]experimental_android_rewrite_dexes_with_rex</a></code> default: "false"</dt>
<dd>
<p>use rex tool to rewrite dex files</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_collect_code_coverage_for_generated_files"><code><a href="#flag--experimental_collect_code_coverage_for_generated_files">--[no]experimental_collect_code_coverage_for_generated_files</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will also generate collect coverage information for generated files.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_objc_fastbuild_options"><code><a href="#flag--experimental_objc_fastbuild_options">--experimental_objc_fastbuild_options</a>=&lt;comma-separated list of options&gt;</code> default: "-O0,-DDEBUG=1"</dt>
<dd>
<p>Uses these strings as objc fastbuild compiler options.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--experimental_omitfp"><code><a href="#flag--experimental_omitfp">--[no]experimental_omitfp</a></code> default: "false"</dt>
<dd>
<p>If true, use libunwind for stack unwinding, and compile with -fomit-frame-pointer and -fasynchronous-unwind-tables.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_output_paths"><code><a href="#flag--experimental_output_paths">--experimental_output_paths</a>=&lt;off or strip&gt;</code> default: "off"</dt>
<dd>
<p>Which model to use for where in the output tree rules write their outputs, particularly
for multi-platform / multi-configuration builds. This is highly experimental. See
<a href="https://github.com/bazelbuild/bazel/issues/6526">GH-6526</a> for details. Starlark actions can opt into path mapping by adding the key
<code>supports-path-mapping</code> to the <code>execution_requirements</code> dict.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--experimental_override_platform_cpu_name"><code><a href="#flag--experimental_override_platform_cpu_name">--experimental_override_platform_cpu_name</a>=&lt;a &#39;label=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Each entry should be of the form <code>label=value</code> where label refers to a platform and values
is the desired shortname to override the platform's CPU name in <code>$(TARGET_CPU)</code>
make variable and output path. Only used when
<code>--experimental_platform_in_output_dir</code>, <code>--incompatible_target_cpu_from_platform</code> or
<code>--incompatible_bep_cpu_from_platform</code> is true. Has highest naming priority.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_platform_in_output_dir"><code><a href="#flag--experimental_platform_in_output_dir">--[no]experimental_platform_in_output_dir</a></code> default: "Auto"</dt>
<dd>
<p>If true, a shortname for the target platform is used in the output directory name
instead of the CPU. The exact scheme is experimental and subject to change:</p>
<ol>
<li>First, in the rare case the <code>--platforms</code> option does not have exactly one value, a
hash of the platforms option is used.</li>
<li>Next, if any shortname for the current platform was registered by
<code>--experimental_override_name_platform_in_output_dir</code>, then that shortname is used.</li>
<li>Then, if <code>--experimental_use_platforms_in_output_dir_legacy_heuristic</code> is set, use a
shortname based off the current platform Label.</li>
<li>Finally, a hash of the platform option is used as a last resort.</li>
</ol>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_py_binaries_include_label"><code><a href="#flag--experimental_py_binaries_include_label">--[no]experimental_py_binaries_include_label</a></code> default: "false"</dt>
<dd>
<p>py_binary targets include their label even when stamping is disabled.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_use_llvm_covmap"><code><a href="#flag--experimental_use_llvm_covmap">--[no]experimental_use_llvm_covmap</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will generate llvm-cov coverage map information rather than gcov when collect_code_coverage is enabled.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_use_platforms_in_output_dir_legacy_heuristic"><code><a href="#flag--experimental_use_platforms_in_output_dir_legacy_heuristic">--[no]experimental_use_platforms_in_output_dir_legacy_heuristic</a></code> default: "true"</dt>
<dd>
<p>Please only use this flag as part of a suggested migration or testing strategy. Note
that the heuristic has known deficiencies and it is suggested to migrate to
relying on just <code>--experimental_override_name_platform_in_output_dir</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--fdo_instrument"><code><a href="#flag--fdo_instrument">--fdo_instrument</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Generate binaries with FDO instrumentation. With Clang/LLVM compiler, it also accepts the directory name under which the raw profile file(s) will be dumped at runtime.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--fdo_optimize"><code><a href="#flag--fdo_optimize">--fdo_optimize</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Use FDO profile information to optimize compilation. Specify the name of a zip file containing a .gcda file tree, an afdo file containing an auto profile, or an LLVM profile file. This flag also accepts files specified as labels (e.g. <code>//foo/bar:file.afdo</code> - you may need to add an <code>exports_files</code> directive to the corresponding package) and labels pointing to <code>fdo_profile</code> targets. This flag will be superseded by the <code>fdo_profile</code> rule.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--fdo_prefetch_hints"><code><a href="#flag--fdo_prefetch_hints">--fdo_prefetch_hints</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use cache prefetch hints.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--fdo_profile"><code><a href="#flag--fdo_profile">--fdo_profile</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The fdo_profile representing the profile to be used for optimization.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--features"><code><a href="#flag--features">--features</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The given features will be enabled or disabled by default for targets built in the target configuration.
Specifying <code>-{feature}</code> will disable the feature. Negative features always override positive ones.
See also <code>--host_features</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--force_pic"><code><a href="#flag--force_pic">--[no]force_pic</a></code> default: "false"</dt>
<dd>
<p>If enabled, all C++ compilations produce position-independent code (&quot;-fPIC&quot;), links prefer PIC pre-built libraries over non-PIC libraries, and links produce position-independent executables (&quot;-pie&quot;).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_action_env"><code><a href="#flag--host_action_env">--host_action_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the set of environment variables available to actions with execution
configurations. Variables can be either specified by <code>name</code>, in which case the
value will be taken from the invocation environment, by the <code>name=value</code> pair
which sets the value independent of the invocation environment, or by
<code>=name</code>, which unsets the variable of that name. This option can
be used multiple times; for options given for the same variable, the latest
wins, options for different variables accumulate.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--host_compilation_mode"><code><a href="#flag--host_compilation_mode">--host_compilation_mode</a>=&lt;fastbuild, dbg or opt&gt;</code> default: "opt"</dt>
<dd>
<p>Specify the mode the tools used during the build will be built in. Values:
<code>fastbuild</code>, <code>dbg</code>, <code>opt</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--host_conlyopt"><code><a href="#flag--host_conlyopt">--host_conlyopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to the C compiler when compiling C (but not C++) source files in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_copt"><code><a href="#flag--host_copt">--host_copt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the C compiler for tools built in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_cpu"><code><a href="#flag--host_cpu">--host_cpu</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The host CPU.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_cxxopt"><code><a href="#flag--host_cxxopt">--host_cxxopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to C++ compiler for tools built in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_features"><code><a href="#flag--host_features">--host_features</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The given features will be enabled or disabled by default for targets built in the exec configuration.
Specifying <code>-{feature}</code> will disable the feature. Negative features always override positive ones.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_linkopt"><code><a href="#flag--host_linkopt">--host_linkopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to linker when linking tools in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_macos_minimum_os"><code><a href="#flag--host_macos_minimum_os">--host_macos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible macOS version for host targets. If unspecified, uses 'macos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--host_per_file_copt"><code><a href="#flag--host_per_file_copt">--host_per_file_copt</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths followed by an @ and a comma separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to selectively pass to the C/C++ compiler when compiling certain files in the exec configurations. This option can be passed multiple times. Syntax: regex_filter@option_1,option_2,...,option_n. Where regex_filter stands for a list of include and exclude regular expression patterns (Also see --instrumentation_filter). option_1 to option_n stand for arbitrary command line options. If an option contains a comma it has to be quoted with a backslash. Options can contain @. Only the first @ is used to split the string. Example: --host_per_file_copt=//foo/.*.cc,-//foo/bar.cc@-O0 adds the -O0 command line option to the gcc command line of all cc files in //foo/ except bar.cc.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--incompatible_auto_exec_groups"><code><a href="#flag--incompatible_auto_exec_groups">--[no]incompatible_auto_exec_groups</a></code> default: "false"</dt>
<dd>
<p>When enabled, an exec groups is automatically created for each toolchain used by a rule.
For this to work rule needs to specify <code>toolchain</code> parameter on its actions. For
more information, see <a href="https://github.com/bazelbuild/bazel/issues/17134">GH-17134</a>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_merge_genfiles_directory"><code><a href="#flag--incompatible_merge_genfiles_directory">--[no]incompatible_merge_genfiles_directory</a></code> default: "true"</dt>
<dd>
<p>If true, the genfiles directory is folded into the bin directory.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_target_cpu_from_platform"><code><a href="#flag--incompatible_target_cpu_from_platform">--[no]incompatible_target_cpu_from_platform</a></code> default: "true"</dt>
<dd>
<p>If specified, the value of the cpu constraint (<code>@platforms//cpu:cpu</code>) of
the target platform is used to set the <code>$(TARGET_CPU)</code> make variable.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--instrument_test_targets"><code><a href="#flag--instrument_test_targets">--[no]instrument_test_targets</a></code> default: "false"</dt>
<dd>
<p>When coverage is enabled, specifies whether to consider instrumenting test rules.
When set, test rules included by <code>--instrumentation_filter</code> are instrumented.
Otherwise, test rules are always excluded from coverage instrumentation.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--instrumentation_filter"><code><a href="#flag--instrumentation_filter">--instrumentation_filter</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths&gt;</code> default: "-/javatests[/:],-/test/java[/:]"</dt>
<dd>
<p>When coverage is enabled, only rules with names included by the
specified regex-based filter will be instrumented. Rules prefixed
with '-' are excluded instead. Note that only non-test rules are
instrumented unless <code>--instrument_test_targets</code> is enabled.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ios_minimum_os"><code><a href="#flag--ios_minimum_os">--ios_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible iOS version for target simulators and devices. If unspecified, uses 'ios_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--ios_multi_cpus"><code><a href="#flag--ios_multi_cpus">--ios_multi_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures to build an ios_application with. The result is a universal binary containing all specified architectures.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--legacy_whole_archive"><code><a href="#flag--legacy_whole_archive">--[no]legacy_whole_archive</a></code> default: "true"</dt>
<dd>
<p>Deprecated, superseded by --incompatible_remove_legacy_whole_archive (see https://github.com/bazelbuild/bazel/issues/7362 for details). When on, use --whole-archive for cc_binary rules that have linkshared=True and either linkstatic=True or '-static' in linkopts. This is for backwards compatibility only. A better alternative is to use alwayslink=1 where required.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_DEPRECATED"><code>deprecated</code></a>
</p></dd>
<dt id="flag--linkopt"><code><a href="#flag--linkopt">--linkopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to gcc when linking.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ltobackendopt"><code><a href="#flag--ltobackendopt">--ltobackendopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to the LTO backend step (under --features=thin_lto).</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ltoindexopt"><code><a href="#flag--ltoindexopt">--ltoindexopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to the LTO indexing step (under --features=thin_lto).</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--macos_cpus"><code><a href="#flag--macos_cpus">--macos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple macOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--macos_minimum_os"><code><a href="#flag--macos_minimum_os">--macos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible macOS version for targets. If unspecified, uses 'macos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--memprof_profile"><code><a href="#flag--memprof_profile">--memprof_profile</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use memprof profile.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--objc_debug_with_GLIBCXX"><code><a href="#flag--objc_debug_with_GLIBCXX">--[no]objc_debug_with_GLIBCXX</a></code> default: "false"</dt>
<dd>
<p>If set, and compilation mode is set to 'dbg', define GLIBCXX_DEBUG,  GLIBCXX_DEBUG_PEDANTIC and GLIBCPP_CONCEPT_CHECKS.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--objc_enable_binary_stripping"><code><a href="#flag--objc_enable_binary_stripping">--[no]objc_enable_binary_stripping</a></code> default: "false"</dt>
<dd>
<p>Whether to perform symbol and dead-code strippings on linked binaries. Binary strippings will be performed if both this flag and --compilation_mode=opt are specified.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--objccopt"><code><a href="#flag--objccopt">--objccopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to gcc when compiling Objective-C/C++ source files.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--per_file_copt"><code><a href="#flag--per_file_copt">--per_file_copt</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths followed by an @ and a comma separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to selectively pass to gcc when compiling certain files. This option can be passed multiple times. Syntax: regex_filter@option_1,option_2,...,option_n. Where regex_filter stands for a list of include and exclude regular expression patterns (Also see --instrumentation_filter). option_1 to option_n stand for arbitrary command line options. If an option contains a comma it has to be quoted with a backslash. Options can contain @. Only the first @ is used to split the string. Example: --per_file_copt=//foo/.*.cc,-//foo/bar.cc@-O0 adds the -O0 command line option to the gcc command line of all cc files in //foo/ except bar.cc.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--per_file_ltobackendopt"><code><a href="#flag--per_file_ltobackendopt">--per_file_ltobackendopt</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths followed by an @ and a comma separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to selectively pass to LTO backend (under --features=thin_lto) when compiling certain backend objects. This option can be passed multiple times. Syntax: regex_filter@option_1,option_2,...,option_n. Where regex_filter stands for a list of include and exclude regular expression patterns. option_1 to option_n stand for arbitrary command line options. If an option contains a comma it has to be quoted with a backslash. Options can contain @. Only the first @ is used to split the string. Example: --per_file_ltobackendopt=//foo/.*.o,-//foo/bar.o@-O0 adds the -O0 command line option to the LTO backend command line of all o files in //foo/ except bar.o.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--platform_suffix"><code><a href="#flag--platform_suffix">--platform_suffix</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specifies a suffix to be added to the configuration directory.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--propeller_optimize"><code><a href="#flag--propeller_optimize">--propeller_optimize</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use Propeller profile information to optimize the build target.A propeller profile must consist of at least one of two files, a cc profile and a ld profile.  This flag accepts a build label which must refer to the propeller profile input files. For example, the BUILD file that defines the label, in a/b/BUILD:propeller_optimize(    name = &quot;propeller_profile&quot;,    cc_profile = &quot;propeller_cc_profile.txt&quot;,    ld_profile = &quot;propeller_ld_profile.txt&quot;,)An exports_files directive may have to be added to the corresponding package to make these files visible to Bazel. The option must be used as: --propeller_optimize=//a/b:propeller_profile</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--propeller_optimize_absolute_cc_profile"><code><a href="#flag--propeller_optimize_absolute_cc_profile">--propeller_optimize_absolute_cc_profile</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Absolute path name of cc_profile file for Propeller Optimized builds.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--propeller_optimize_absolute_ld_profile"><code><a href="#flag--propeller_optimize_absolute_ld_profile">--propeller_optimize_absolute_ld_profile</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Absolute path name of ld_profile file for Propeller Optimized builds.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--run_under"><code><a href="#flag--run_under">--run_under</a>=&lt;a prefix in front of command&gt;</code> default: see description</dt>
<dd>
<p>Prefix to insert before the executables for the <code>test</code> and <code>run</code> commands.
If the value is <code>foo -bar</code>, and the execution command line is <code>test_binary -baz</code>,
then the final command line is <code>foo -bar test_binary -baz</code>.
This can also be a label to an executable target. Some examples are:</p>
<ul>
<li><code>valgrind</code></li>
<li><code>strace</code></li>
<li><code>strace -c</code></li>
<li><code>valgrind --quiet --num-callers=20</code></li>
<li><code>//package:target</code></li>
<li><code>//package:target --options</code></li>
</ul>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--share_native_deps"><code><a href="#flag--share_native_deps">--[no]share_native_deps</a></code> default: "true"</dt>
<dd>
<p>If true, native libraries that contain identical functionality will be shared among different targets</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--stamp"><code><a href="#flag--stamp">--[no]stamp</a></code> default: "false"</dt>
<dd>
<p>Stamp binaries with the date, username, hostname, workspace information, etc.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--strip"><code><a href="#flag--strip">--strip</a>=&lt;always, sometimes or never&gt;</code> default: "sometimes"</dt>
<dd>
<p>Specifies whether to strip binaries and shared libraries  (using &quot;-Wl,--strip-debug&quot;).  The default value of 'sometimes' means strip iff --compilation_mode=fastbuild.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--stripopt"><code><a href="#flag--stripopt">--stripopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to strip when generating a '&lt;name&gt;.stripped' binary.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--tvos_cpus"><code><a href="#flag--tvos_cpus">--tvos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple tvOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--tvos_minimum_os"><code><a href="#flag--tvos_minimum_os">--tvos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible tvOS version for target simulators and devices. If unspecified, uses 'tvos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--visionos_cpus"><code><a href="#flag--visionos_cpus">--visionos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple visionOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--watchos_cpus"><code><a href="#flag--watchos_cpus">--watchos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple watchOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--watchos_minimum_os"><code><a href="#flag--watchos_minimum_os">--watchos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible watchOS version for target simulators and devices. If unspecified, uses 'watchos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--xbinary_fdo"><code><a href="#flag--xbinary_fdo">--xbinary_fdo</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use XbinaryFDO profile information to optimize compilation. Specify the name of default cross binary profile. When the option is used together with --fdo_instrument/--fdo_optimize/--fdo_profile, those options will always prevail as if xbinary_fdo is never specified.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
</dl>
<dl>Options that affect how strictly Bazel enforces valid build inputs (rule definitions,  flag combinations, etc.):
<dt id="flag--check_visibility"><code><a href="#flag--check_visibility">--[no]check_visibility</a></code> default: "true"</dt>
<dd>
<p>If disabled, visibility errors in target dependencies are demoted to warnings.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--desugar_for_android"><code><a href="#flag--desugar_for_android">--[no]desugar_for_android</a></code> default: "true"</dt>
<dd>
<p>Whether to desugar Java 8 bytecode before dexing.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--desugar_java8_libs"><code><a href="#flag--desugar_java8_libs">--[no]desugar_java8_libs</a></code> default: "false"</dt>
<dd>
<p>Whether to include supported Java 8 libraries in apps for legacy devices.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--enforce_constraints"><code><a href="#flag--enforce_constraints">--[no]enforce_constraints</a></code> default: "true"</dt>
<dd>
<p>Checks the environments each target is compatible with and reports errors if any target has dependencies that don't support the same environments</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="flag--experimental_check_desugar_deps"><code><a href="#flag--experimental_check_desugar_deps">--[no]experimental_check_desugar_deps</a></code> default: "true"</dt>
<dd>
<p>Whether to double-check correct desugaring at Android binary level.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_enforce_transitive_visibility"><code><a href="#flag--experimental_enforce_transitive_visibility">--[no]experimental_enforce_transitive_visibility</a></code> default: "false"</dt>
<dd>
<p>If true, enable package()s to set the transitive_visibility attribute to restrict which packages may depend on them.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_one_version_enforcement"><code><a href="#flag--experimental_one_version_enforcement">--experimental_one_version_enforcement</a>=&lt;off, warning or error&gt;</code> default: "OFF"</dt>
<dd>
<p>When enabled, enforce that a java_binary rule can't contain more than one version of the same class file on the classpath. This enforcement can break the build, or can just result in warnings.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--experimental_strict_java_deps"><code><a href="#flag--experimental_strict_java_deps">--experimental_strict_java_deps</a>=&lt;off, warn, error, strict or default&gt;</code> default: "default"</dt>
<dd>
<p>If true, checks that a Java target explicitly declares all directly used targets as dependencies.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="flag--incompatible_check_testonly_for_output_files"><code><a href="#flag--incompatible_check_testonly_for_output_files">--[no]incompatible_check_testonly_for_output_files</a></code> default: "false"</dt>
<dd>
<p>If enabled, check testonly for prerequisite targets that are output files by looking up the testonly of the generating rule. This matches visibility checking.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_disable_native_android_rules"><code><a href="#flag--incompatible_disable_native_android_rules">--[no]incompatible_disable_native_android_rules</a></code> default: "false"</dt>
<dd>
<p>If enabled, direct usage of the native Android rules is disabled. Please use the Starlark Android rules from https://github.com/bazelbuild/rules_android</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_disable_native_apple_binary_rule"><code><a href="#flag--incompatible_disable_native_apple_binary_rule">--[no]incompatible_disable_native_apple_binary_rule</a></code> default: "false"</dt>
<dd>
<p>No-op. Kept here for backwards compatibility.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--one_version_enforcement_on_java_tests"><code><a href="#flag--one_version_enforcement_on_java_tests">--[no]one_version_enforcement_on_java_tests</a></code> default: "true"</dt>
<dd>
<p>When enabled, and with experimental_one_version_enforcement set to a non-NONE value, enforce one version on java_test targets. This flag can be disabled to improve incremental test performance at the expense of missing potential one version violations.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--python_native_rules_allowlist"><code><a href="#flag--python_native_rules_allowlist">--python_native_rules_allowlist</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>An allowlist (package_group target) to use when enforcing --incompatible_python_disallow_native_rules.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--strict_filesets"><code><a href="#flag--strict_filesets">--[no]strict_filesets</a></code> default: "false"</dt>
<dd>
<p>If this option is enabled, filesets crossing package boundaries are reported as errors.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="flag--strict_proto_deps"><code><a href="#flag--strict_proto_deps">--strict_proto_deps</a>=&lt;off, warn, error, strict or default&gt;</code> default: "error"</dt>
<dd>
<p>Unless OFF, checks that a proto_library target explicitly declares all directly used targets as dependencies.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--strict_public_imports"><code><a href="#flag--strict_public_imports">--strict_public_imports</a>=&lt;off, warn, error, strict or default&gt;</code> default: "off"</dt>
<dd>
<p>Unless OFF, checks that a proto_library target explicitly declares all targets used in 'import public' as exported.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--strict_system_includes"><code><a href="#flag--strict_system_includes">--[no]strict_system_includes</a></code> default: "false"</dt>
<dd>
<p>If true, headers found through system include paths (-isystem) are also required to be declared.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="flag--target_environment"><code><a href="#flag--target_environment">--target_environment</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Declares this build's target environment. Must be a label reference to an
<a href="https://github.com/bazelbuild/bazel/blob/master/src/main/java/com/google/devtools/build/lib/analysis/constraints/EnvironmentRule.java"><code>environment</code> rule</a>. If specified, all top-level targets must be compatible with this
environment.</p>
<p>See also <code>--platforms</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
</dl>
<dl>Options that affect the signing outputs of a build:
<dt id="flag--apk_signing_method"><code><a href="#flag--apk_signing_method">--apk_signing_method</a>=&lt;v1, v2, v1_v2 or v4&gt;</code> default: "v1_v2"</dt>
<dd>
<p>Implementation to use to sign APKs</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--device_debug_entitlements"><code><a href="#flag--device_debug_entitlements">--[no]device_debug_entitlements</a></code> default: "true"</dt>
<dd>
<p>If set, and compilation mode is not 'opt', objc apps will include debug entitlements when signing.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="flag--ios_signing_cert_name"><code><a href="#flag--ios_signing_cert_name">--ios_signing_cert_name</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Certificate name to use for iOS signing. If not set will fall back to provisioning profile. May be the certificate's keychain identity preference or (substring) of the certificate's common name, as per codesign's man page (SIGNING IDENTITIES).</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
</dl>
<dl>This option affects semantics of the Starlark language or the build API accessible to BUILD files, .bzl files, or WORKSPACE files.:
<dt id="flag--incompatible_disallow_sdk_frameworks_attributes"><code><a href="#flag--incompatible_disallow_sdk_frameworks_attributes">--[no]incompatible_disallow_sdk_frameworks_attributes</a></code> default: "false"</dt>
<dd>
<p>If true, disallow sdk_frameworks and weak_sdk_frameworks attributes in objc_library andobjc_import.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_objc_alwayslink_by_default"><code><a href="#flag--incompatible_objc_alwayslink_by_default">--[no]incompatible_objc_alwayslink_by_default</a></code> default: "false"</dt>
<dd>
<p>If true, make the default value true for alwayslink attributes in objc_library and objc_import.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_python_disallow_native_rules"><code><a href="#flag--incompatible_python_disallow_native_rules">--[no]incompatible_python_disallow_native_rules</a></code> default: "false"</dt>
<dd>
<p>When true, an error occurs when using the builtin py_* rules; instead the rule_python rules should be used. See https://github.com/bazelbuild/bazel/issues/17773 for more information and migration instructions.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options that govern the behavior of the test environment or test runner:
<dt id="flag--allow_analysis_failures"><code><a href="#flag--allow_analysis_failures">--[no]allow_analysis_failures</a></code> default: "false"</dt>
<dd>
<p>If true, an analysis failure of a rule target results in the target's propagation
of an instance of <code>AnalysisFailureInfo</code> containing the error description, instead
of resulting in a build failure.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--analysis_testing_deps_limit"><code><a href="#flag--analysis_testing_deps_limit">--analysis_testing_deps_limit</a>=&lt;an integer&gt;</code> default: "2000"</dt>
<dd>
<p>Sets the maximum number of transitive dependencies through a rule attribute with
a <code>for_analysis_testing</code> configuration transition.
Exceeding this limit will result in a rule error.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--break_build_on_parallel_dex2oat_failure"><code><a href="#flag--break_build_on_parallel_dex2oat_failure">--[no]break_build_on_parallel_dex2oat_failure</a></code> default: "false"</dt>
<dd>
<p>If true dex2oat action failures will cause the build to break instead of executing dex2oat during test runtime.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--default_test_resources"><code><a href="#flag--default_test_resources">--default_test_resources</a>=&lt;a resource name followed by equal and 1 float or 4 float, e.g memory=10,30,60,100&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Override the default resources amount for tests. The expected format is
<code>{resource}={value}</code>. If a single positive number is specified as <code>{value}</code>
it will override the default resources for all test sizes. If 4
comma-separated numbers are specified, they will override the resource
amount for respectively the <code>small</code>, <code>medium</code>, <code>large</code>, <code>enormous</code> test sizes.
Values can also be <code>HOST_RAM</code>/<code>HOST_CPU</code>, optionally followed
by <code>[-|*]{float}</code> (eg. <code>memory=HOST_RAM*.1,HOST_RAM*.2,HOST_RAM*.3,HOST_RAM*.4</code>).
The default test resources specified by this flag are overridden by explicit
resources specified in tags.</p>
</dd>
<dt id="flag--experimental_android_use_parallel_dex2oat"><code><a href="#flag--experimental_android_use_parallel_dex2oat">--[no]experimental_android_use_parallel_dex2oat</a></code> default: "false"</dt>
<dd>
<p>Use dex2oat in parallel to possibly speed up android_test.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--ios_memleaks"><code><a href="#flag--ios_memleaks">--[no]ios_memleaks</a></code> default: "false"</dt>
<dd>
<p>Enable checking for memory leaks in ios_test targets.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--ios_simulator_device"><code><a href="#flag--ios_simulator_device">--ios_simulator_device</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The device to simulate when running an iOS application in the simulator, e.g. 'iPhone 6'. You can get a list of devices by running 'xcrun simctl list devicetypes' on the machine the simulator will be run on.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
<dt id="flag--ios_simulator_version"><code><a href="#flag--ios_simulator_version">--ios_simulator_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>The version of iOS to run on the simulator when running or testing. This is ignored for ios_test rules if a target device is specified in the rule.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
<dt id="flag--runs_per_test"><code><a href="#flag--runs_per_test">--runs_per_test</a>=&lt;a positive integer or test_regex@runs. This flag may be passed more than once&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies number of times to run each test. If any of those attempts fail for any
reason, the whole test is considered failed. Normally the value specified is
just an integer.</p>
<p>Example: <code>--runs_per_test=3</code> will run all tests 3 times.</p>
<p>Alternate syntax: <code>regex_filter@runs_per_test</code>. Where <code>runs_per_test</code> stands for
an integer value and <code>regex_filter</code> stands for a list of include and exclude
regular expression patterns (Also see --instrumentation_filter).</p>
<p>Example: <code>--runs_per_test=//foo/.*,-//foo/bar/.*@3</code> runs all tests in <code>//foo/</code> except
those under <code>//foo/bar</code> three times. This option can be passed multiple times. The most
recently passed argument that matches takes precedence. If nothing matches,
the test is only run once.</p>
</dd>
<dt id="flag--test_env"><code><a href="#flag--test_env">--test_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies additional environment variables to be injected into the test runner
environment. Variables can be either specified by <code>name</code>, in which
case its value will be read from the Bazel client environment, or by the
<code>name=value</code> pair.
Previously set variables can be unset via <code>=name</code>.
This option can be used multiple times to specify several variables.
Used only by the 'bazel test' command.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
<dt id="flag--test_timeout"><code><a href="#flag--test_timeout">--test_timeout</a>=&lt;a single integer or comma-separated list of 4 integers&gt;</code> default: "-1"</dt>
<dd>
<p>Override the default test timeout values for test timeouts (in secs). If a single
positive integer value is specified it will override all categories.  If 4
comma-separated integers are specified, they will override the timeouts for
<code>short</code>, <code>moderate</code>, <code>long</code> and <code>eternal</code> (in that order). In either form, a value of
-1 tells blaze to use its default timeouts for that category.</p>
</dd>
<dt id="flag--zip_undeclared_test_outputs"><code><a href="#flag--zip_undeclared_test_outputs">--[no]zip_undeclared_test_outputs</a></code> default: "false"</dt>
<dd>
<p>If true, undeclared test outputs will be archived in a zip file.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
</dl>
<dl>Options that trigger optimizations of the build time:
<dt id="flag--cc_dotd_files"><code><a href="#flag--cc_dotd_files">--[no]cc_dotd_files</a></code> default: "true"</dt>
<dd>
<p>Whether to generate and analyze .d files.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="flag--cc_include_scanning"><code><a href="#flag--cc_include_scanning">--[no]cc_include_scanning</a></code> default: "false"</dt>
<dd>
<p>Whether to narrow inputs to C/C++ compilation by parsing #include lines from input files. This can improve performance and incrementality by decreasing the size of compilation input trees. However, it can also break builds because the include scanner does not fully implement C preprocessor semantics. In particular, it does not understand dynamic #include directives and ignores preprocessor conditional logic. Use at your own risk. Any issues relating to this flag that are filed will be closed. At Google without this flag your build will most likely fail.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_filter_library_jar_with_program_jar"><code><a href="#flag--experimental_filter_library_jar_with_program_jar">--[no]experimental_filter_library_jar_with_program_jar</a></code> default: "false"</dt>
<dd>
<p>Filter the ProGuard ProgramJar to remove any classes also present in the LibraryJar.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_inmemory_dotd_files"><code><a href="#flag--experimental_inmemory_dotd_files">--[no]experimental_inmemory_dotd_files</a></code> default: "true"</dt>
<dd>
<p>If enabled, C++ .d files will be passed through in memory directly from the remote build nodes instead of being written to disk.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_inmemory_jdeps_files"><code><a href="#flag--experimental_inmemory_jdeps_files">--[no]experimental_inmemory_jdeps_files</a></code> default: "true"</dt>
<dd>
<p>If enabled, the dependency (.jdeps) files generated from Java compilations will be passed through in memory directly from the remote build nodes instead of being written to disk.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_retain_test_configuration_across_testonly"><code><a href="#flag--experimental_retain_test_configuration_across_testonly">--[no]experimental_retain_test_configuration_across_testonly</a></code> default: "false"</dt>
<dd>
<p>When enabled, <code>--trim_test_configuration</code> will not trim the test configuration for rules
marked testonly=1. This is meant to reduce action conflict issues when non-test
rules depend on <code>cc_test</code> rules. No effect if <code>--trim_test_configuration</code> is
false.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_unsupported_and_brittle_include_scanning"><code><a href="#flag--experimental_unsupported_and_brittle_include_scanning">--[no]experimental_unsupported_and_brittle_include_scanning</a></code> default: "false"</dt>
<dd>
<p>Whether to narrow inputs to C/C++ compilation by parsing #include lines from input files. This can improve performance and incrementality by decreasing the size of compilation input trees. However, it can also break builds because the include scanner does not fully implement C preprocessor semantics. In particular, it does not understand dynamic #include directives and ignores preprocessor conditional logic. Use at your own risk. Any issues relating to this flag that are filed will be closed. At Google without this flag your build will most likely fail.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--incremental_dexing"><code><a href="#flag--incremental_dexing">--[no]incremental_dexing</a></code> default: "true"</dt>
<dd>
<p>Does most of the work for dexing separately for each Jar file.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--objc_use_dotd_pruning"><code><a href="#flag--objc_use_dotd_pruning">--[no]objc_use_dotd_pruning</a></code> default: "true"</dt>
<dd>
<p>If set, .d files emitted by clang will be used to prune the set of inputs passed into objc compiles.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--process_headers_in_dependencies"><code><a href="#flag--process_headers_in_dependencies">--[no]process_headers_in_dependencies</a></code> default: "false"</dt>
<dd>
<p>When building a target //a:a, process headers in all targets that //a:a depends on (if header processing is enabled for the toolchain).</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--trim_test_configuration"><code><a href="#flag--trim_test_configuration">--[no]trim_test_configuration</a></code> default: "true"</dt>
<dd>
<p>When enabled, test-related options will be cleared below the top level of the build. When this flag is active, tests cannot be built as dependencies of non-test rules, but changes to test-related options will not cause non-test rules to be re-analyzed.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
</dl>
<dl>Options that affect the verbosity, format or location of logging:
<dt id="flag--toolchain_resolution_debug"><code><a href="#flag--toolchain_resolution_debug">--toolchain_resolution_debug</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths&gt;</code> default: "-.*"</dt>
<dd>
<p>Print debug information during toolchain resolution. The flag takes a regex, which is checked against toolchain types and specific targets to see which to debug. Multiple regexes may be  separated by commas, and then each regex is checked separately. Note: The output of this flag is very complex and will likely only be useful to experts in toolchain resolution.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="flag--verbose_visibility_errors"><code><a href="#flag--verbose_visibility_errors">--[no]verbose_visibility_errors</a></code> default: "false"</dt>
<dd>
<p>If enabled, visibility errors include additional diagnostic information.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
</dl>
<dl>Options specifying or altering a generic input to a Bazel command that does not fall into other categories.:
<dt id="flag--flag_alias"><code><a href="#flag--flag_alias">--flag_alias</a>=&lt;a &#39;name=value&#39; flag alias&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Sets a shorthand name for a Starlark flag. It takes a single key-value pair in the form
<code>{key}={value}</code> as an argument.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--incompatible_default_to_explicit_init_py"><code><a href="#flag--incompatible_default_to_explicit_init_py">--[no]incompatible_default_to_explicit_init_py</a></code> default: "false"</dt>
<dd>
<p>This flag changes the default behavior so that <strong>init</strong>.py files are no longer automatically created in the runfiles of Python targets. Precisely, when a py_binary or py_test target has legacy_create_init set to &quot;auto&quot; (the default), it is treated as false if and only if this flag is set. See https://github.com/bazelbuild/bazel/issues/10076.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Miscellaneous options, not otherwise categorized.:
<dt id="flag--cache_test_results"><code><a href="#flag--cache_test_results">--[no]cache_test_results</a></code> [<code>-t</code>] default: "auto"</dt>
<dd>
<p>If set to <code>auto</code>, Bazel reruns a test if and only if:</p>
<ol>
<li>Bazel detects changes in the test or its dependencies,</li>
<li>The test is marked as <code>external</code>,</li>
<li>Multiple test runs were requested with <code>--runs_per_test</code>, or</li>
<li>The test previously failed.
If set to <code>yes</code>, Bazel caches all test results except for tests marked as
<code>external</code>. If set to <code>no</code>, Bazel does not cache any test results.</li>
</ol>
</dd>
<dt id="flag--experimental_cancel_concurrent_tests"><code><a href="#flag--experimental_cancel_concurrent_tests">--[no]experimental_cancel_concurrent_tests</a></code> default: "never"</dt>
<dd>
<p>If <code>on_failed</code> or <code>on_passed</code>, then Blaze will cancel concurrently running tests on the first
successful run with that result. This is only useful in combination with
<code>--runs_per_test_detects_flakes</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_fetch_all_coverage_outputs"><code><a href="#flag--experimental_fetch_all_coverage_outputs">--[no]experimental_fetch_all_coverage_outputs</a></code> default: "false"</dt>
<dd>
<p>If true, then Bazel fetches the entire coverage data directory for each test during a coverage run.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_generate_llvm_lcov"><code><a href="#flag--experimental_generate_llvm_lcov">--[no]experimental_generate_llvm_lcov</a></code> default: "false"</dt>
<dd>
<p>If true, coverage for clang will generate an LCOV report.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_java_classpath"><code><a href="#flag--experimental_java_classpath">--experimental_java_classpath</a>=&lt;off, javabuilder, bazel or bazel_no_fallback&gt;</code> default: "bazel"</dt>
<dd>
<p>Enables reduced classpaths for Java compilations.</p>
</dd>
<dt id="flag--experimental_run_android_lint_on_java_rules"><code><a href="#flag--experimental_run_android_lint_on_java_rules">--[no]experimental_run_android_lint_on_java_rules</a></code> default: "false"</dt>
<dd>
<p>Whether to validate java_* sources.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--explicit_java_test_deps"><code><a href="#flag--explicit_java_test_deps">--[no]explicit_java_test_deps</a></code> default: "false"</dt>
<dd>
<p>Explicitly specify a dependency to JUnit or Hamcrest in a java_test instead of  accidentally obtaining from the TestRunner's deps. Only works for bazel right now.</p>
</dd>
<dt id="flag--host_java_launcher"><code><a href="#flag--host_java_launcher">--host_java_launcher</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The Java launcher used by tools that are executed during a build.</p>
</dd>
<dt id="flag--host_javacopt"><code><a href="#flag--host_javacopt">--host_javacopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to javac when building tools that are executed during a build.</p>
</dd>
<dt id="flag--host_jvmopt"><code><a href="#flag--host_jvmopt">--host_jvmopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the Java VM when building tools that are executed during  the build. These options will get added to the VM startup options of each  java_binary target.</p>
</dd>
<dt id="flag--incompatible_check_sharding_support"><code><a href="#flag--incompatible_check_sharding_support">--[no]incompatible_check_sharding_support</a></code> default: "true"</dt>
<dd>
<p>If true, Bazel will fail a sharded test if the test runner does not indicate that it
supports sharding by touching the file at the path in <code>TEST_SHARD_STATUS_FILE</code>.
If false, a test runner that does not support sharding will lead to all tests
running in each shard.</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_exclusive_test_sandboxed"><code><a href="#flag--incompatible_exclusive_test_sandboxed">--[no]incompatible_exclusive_test_sandboxed</a></code> default: "true"</dt>
<dd>
<p>If true, exclusive tests will run with sandboxed strategy. Add <code>local</code> tag to force
an exclusive test run locally</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_strict_action_env"><code><a href="#flag--incompatible_strict_action_env">--[no]incompatible_strict_action_env</a></code> default: "false"</dt>
<dd>
<p>If true, Bazel uses an environment with a static value for PATH and does not
inherit <code>LD_LIBRARY_PATH</code>. Use <code>--action_env=ENV_VARIABLE</code> if you want to
inherit specific environment variables from the client, but note that doing so
can prevent cross-user caching if a shared cache is used.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--j2objc_translation_flags"><code><a href="#flag--j2objc_translation_flags">--j2objc_translation_flags</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the J2ObjC tool.</p>
</dd>
<dt id="flag--java_debug"><code><a href="#flag--java_debug">--java_debug</a></code></dt>
<dd>
<p>Causes the Java virtual machine of a java test to wait for a connection from a JDWP-compliant debugger (such as jdb) before starting the test. Implies -test_output=streamed.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--test_arg">--test_arg=--wrapper_script_flag=--debug</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--test_output">--test_output=streamed</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--test_strategy">--test_strategy=exclusive</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--test_timeout">--test_timeout=9999</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--nocache_test_results">--nocache_test_results</a></code>
</p></dd>
<dt id="flag--java_deps"><code><a href="#flag--java_deps">--[no]java_deps</a></code> default: "true"</dt>
<dd>
<p>Generate dependency information (for now, compile-time classpath) per Java target.</p>
</dd>
<dt id="flag--java_header_compilation"><code><a href="#flag--java_header_compilation">--[no]java_header_compilation</a></code> default: "true"</dt>
<dd>
<p>Compile ijars directly from source.</p>
</dd>
<dt id="flag--java_language_version"><code><a href="#flag--java_language_version">--java_language_version</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The Java language version</p>
</dd>
<dt id="flag--java_launcher"><code><a href="#flag--java_launcher">--java_launcher</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The Java launcher to use when building Java binaries.  If this flag is set to the empty string, the JDK launcher is used. The &quot;launcher&quot; attribute overrides this flag.</p>
</dd>
<dt id="flag--java_runtime_version"><code><a href="#flag--java_runtime_version">--java_runtime_version</a>=&lt;a string&gt;</code> default: "local_jdk"</dt>
<dd>
<p>The Java runtime version</p>
</dd>
<dt id="flag--javacopt"><code><a href="#flag--javacopt">--javacopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to javac.</p>
</dd>
<dt id="flag--jvmopt"><code><a href="#flag--jvmopt">--jvmopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the Java VM. These options will get added to the VM startup options of each java_binary target.</p>
</dd>
<dt id="flag--legacy_main_dex_list_generator"><code><a href="#flag--legacy_main_dex_list_generator">--legacy_main_dex_list_generator</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies a binary to use to generate the list of classes that must be in the main dex when compiling legacy multidex.</p>
</dd>
<dt id="flag--optimizing_dexer"><code><a href="#flag--optimizing_dexer">--optimizing_dexer</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies a binary to use to do dexing without sharding.</p>
</dd>
<dt id="flag--plugin"><code><a href="#flag--plugin">--plugin</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Plugins to use in the build. Currently works with java_plugin.</p>
</dd>
<dt id="flag--proguard_top"><code><a href="#flag--proguard_top">--proguard_top</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies which version of ProGuard to use for code removal when building a Java binary.</p>
</dd>
<dt id="flag--proto_compiler"><code><a href="#flag--proto_compiler">--proto_compiler</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:protoc"</dt>
<dd>
<p>The label of the proto-compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_profile"><code><a href="#flag--proto_profile">--[no]proto_profile</a></code> default: "true"</dt>
<dd>
<p>Whether to pass profile_path to the proto compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_profile_path"><code><a href="#flag--proto_profile_path">--proto_profile_path</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The profile to pass to the proto compiler as profile_path. If unset, but  --proto_profile is true (the default), infers the path from --fdo_optimize.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_cc"><code><a href="#flag--proto_toolchain_for_cc">--proto_toolchain_for_cc</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:cc_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile C++ protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_j2objc"><code><a href="#flag--proto_toolchain_for_j2objc">--proto_toolchain_for_j2objc</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/j2objc:j2objc_proto_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile j2objc protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_java"><code><a href="#flag--proto_toolchain_for_java">--proto_toolchain_for_java</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:java_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile Java protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_javalite"><code><a href="#flag--proto_toolchain_for_javalite">--proto_toolchain_for_javalite</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:javalite_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile JavaLite protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--protocopt"><code><a href="#flag--protocopt">--protocopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the protobuf compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--runs_per_test_detects_flakes"><code><a href="#flag--runs_per_test_detects_flakes">--[no]runs_per_test_detects_flakes</a></code> default: "false"</dt>
<dd>
<p>If true, any shard in which at least one run/attempt passes and at least one run/attempt fails gets a FLAKY status.</p>
</dd>
<dt id="flag--shell_executable"><code><a href="#flag--shell_executable">--shell_executable</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>Absolute path to the shell executable for Bazel to use. If this is unset, but the
<code>BAZEL_SH</code> environment variable is set on the first Bazel invocation (that starts
up a Bazel server), Bazel uses that. If neither is set, Bazel uses a hard-coded
default path depending on the operating system it runs on;</p>
<ul>
<li>Windows: <code>c:/msys64/usr/bin/bash.exe</code></li>
<li>FreeBSD: <code>/usr/local/bin/bash</code></li>
<li>All others: <code>/bin/bash</code>.</li>
</ul>
<p>Note that using a shell that is not compatible with <code>bash</code> may lead
to build failures or runtime failures of the generated binaries.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--test_arg"><code><a href="#flag--test_arg">--test_arg</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies additional options and arguments that should be passed to the test
executable. Can be used multiple times to specify several arguments.
If multiple tests are executed, each of them will receive identical arguments.
Used only by the <code>bazel test</code> command.</p>
</dd>
<dt id="flag--test_filter"><code><a href="#flag--test_filter">--test_filter</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specifies a filter to forward to the test framework.  Used to limit the tests run. Note that this does not affect which targets are built.</p>
</dd>
<dt id="flag--test_result_expiration"><code><a href="#flag--test_result_expiration">--test_result_expiration</a>=&lt;an integer&gt;</code> default: "-1"</dt>
<dd>
<p>This option is deprecated and has no effect.</p>
</dd>
<dt id="flag--test_runner_fail_fast"><code><a href="#flag--test_runner_fail_fast">--[no]test_runner_fail_fast</a></code> default: "false"</dt>
<dd>
<p>Forwards fail fast option to the test runner. The test runner should stop execution upon first failure.</p>
</dd>
<dt id="flag--test_sharding_strategy"><code><a href="#flag--test_sharding_strategy">--test_sharding_strategy</a>=&lt;explicit, disabled or forced=k where k is the number of shards to enforce&gt;</code> default: "explicit"</dt>
<dd>
<p>Specify strategy for test sharding:</p>
<ul>
<li><code>explicit</code> to only use sharding if the <code>shard_count</code> <code>BUILD</code> attribute is
present.</li>
<li><code>disabled</code> to never use test sharding.</li>
<li><code>forced=k</code> to enforce <code>k</code> shards for testing regardless of the <code>shard_count</code> <code>BUILD</code>
attribute.</li>
</ul>
</dd>
<dt id="flag--tool_java_language_version"><code><a href="#flag--tool_java_language_version">--tool_java_language_version</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The Java language version used to execute the tools that are needed during a build</p>
</dd>
<dt id="flag--tool_java_runtime_version"><code><a href="#flag--tool_java_runtime_version">--tool_java_runtime_version</a>=&lt;a string&gt;</code> default: "remotejdk_11"</dt>
<dd>
<p>The Java runtime version used to execute tools during the build</p>
</dd>
<dt id="flag--use_ijars"><code><a href="#flag--use_ijars">--[no]use_ijars</a></code> default: "true"</dt>
<dd>
<p>If enabled, this option causes Java compilation to use interface jars. This will result in faster incremental compilation, but error messages can be different.</p>
</dd>
</dl>

<h2><a name="canonicalize-flags">Canonicalize-flags Options</a></h2>
<p>Inherits all options from <a href="#build">build</a>.</p>

<dl>Options that control the output of the command:
<dt id="canonicalize-flags-flag--canonicalize_policy"><code id="canonicalize_policy"><a href="#canonicalize-flags-flag--canonicalize_policy">--[no]canonicalize_policy</a></code> default: "false"</dt>
<dd>
<p>Output the canonical policy, after expansion and filtering. To keep the output clean, the canonicalized command arguments will NOT be shown when this option is set to true. Note that the command specified by --for_command affects the filtered policy, and if none is specified, the default command is 'build'.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="canonicalize-flags-flag--experimental_include_default_values"><code id="experimental_include_default_values"><a href="#canonicalize-flags-flag--experimental_include_default_values">--[no]experimental_include_default_values</a></code> default: "true"</dt>
<dd>
<p>Whether Starlark options set to their default values are included in the output.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
</dl>
<dl>This option affects semantics of the Starlark language or the build API accessible to BUILD files, .bzl files, or WORKSPACE files.:
<dt id="canonicalize-flags-flag--incompatible_config_setting_private_default_visibility"><code id="incompatible_config_setting_private_default_visibility"><a href="#canonicalize-flags-flag--incompatible_config_setting_private_default_visibility">--[no]incompatible_config_setting_private_default_visibility</a></code> default: "false"</dt>
<dd>
<p>If incompatible_enforce_config_setting_visibility=false, this is a noop. Else, if this flag is false, any config_setting without an explicit visibility attribute is //visibility:public. If this flag is true, config_setting follows the same visibility logic as all other rules. See https://github.com/bazelbuild/bazel/issues/12933.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="canonicalize-flags-flag--incompatible_enforce_config_setting_visibility"><code id="incompatible_enforce_config_setting_visibility"><a href="#canonicalize-flags-flag--incompatible_enforce_config_setting_visibility">--[no]incompatible_enforce_config_setting_visibility</a></code> default: "true"</dt>
<dd>
<p>If true, enforce config_setting visibility restrictions. If false, every config_setting is visible to every target. See https://github.com/bazelbuild/bazel/issues/12932.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options specifying or altering a generic input to a Bazel command that does not fall into other categories.:
<dt id="canonicalize-flags-flag--for_command"><code id="for_command"><a href="#canonicalize-flags-flag--for_command">--for_command</a>=&lt;a string&gt;</code> default: "build"</dt>
<dd>
<p>The command for which the options should be canonicalized.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="canonicalize-flags-flag--invocation_policy"><code id="invocation_policy"><a href="#canonicalize-flags-flag--invocation_policy">--invocation_policy</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Applies an invocation policy to the options to be canonicalized.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
</dl>
<dl>Miscellaneous options, not otherwise categorized.:
<dt id="canonicalize-flags-flag--deleted_packages"><code id="deleted_packages"><a href="#canonicalize-flags-flag--deleted_packages">--deleted_packages</a>=&lt;comma-separated list of package names&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>A comma-separated list of names of packages which the build system will consider non-existent, even if they are visible somewhere on the package path.
Use this option when deleting a subpackage 'x/y' of an existing package 'x'.  For example, after deleting x/y/BUILD in your client, the build system may complain if it encounters a label '//x:y/z' if that is still provided by another package_path entry.  Specifying --deleted_packages x/y avoids this problem.</p>
</dd>
<dt id="canonicalize-flags-flag--fetch"><code id="fetch"><a href="#canonicalize-flags-flag--fetch">--[no]fetch</a></code> default: "true"</dt>
<dd>
<p>Allows the command to fetch external dependencies. If set to false, the command will utilize any cached version of the dependency, and if none exists, the command will result in failure.</p>
</dd>
<dt id="canonicalize-flags-flag--package_path"><code id="package_path"><a href="#canonicalize-flags-flag--package_path">--package_path</a>=&lt;colon-separated list of options&gt;</code> default: "%workspace%"</dt>
<dd>
<p>A colon-separated list of where to look for packages. Elements beginning with '%workspace%' are relative to the enclosing workspace. If omitted or empty, the default is the output of 'bazel info default-package-path'.</p>
</dd>
<dt id="canonicalize-flags-flag--show_loading_progress"><code id="show_loading_progress"><a href="#canonicalize-flags-flag--show_loading_progress">--[no]show_loading_progress</a></code> default: "true"</dt>
<dd>
<p>If enabled, causes Bazel to print &quot;Loading package:&quot; messages.</p>
</dd>
</dl>

<h2><a name="clean">Clean Options</a></h2>
<p>Inherits all options from <a href="#build">build</a>.</p>

<dl>Options that control the output of the command:
<dt id="clean-flag--async"><code id="async"><a href="#clean-flag--async">--[no]async</a></code> default: "false"</dt>
<dd>
<p>If true, output cleaning is asynchronous. When this command completes, it will be safe to execute new commands in the same client, even though the deletion may continue in the background.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="clean-flag--expunge"><code id="expunge"><a href="#clean-flag--expunge">--[no]expunge</a></code> default: "false"</dt>
<dd>
<p>If true, clean removes the entire working tree for this bazel instance, which includes all bazel-created temporary and build output files, and stops the bazel server if it is running.</p>
<p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
<dt id="clean-flag--expunge_async"><code id="expunge_async"><a href="#clean-flag--expunge_async">--expunge_async</a></code></dt>
<dd>
<p>If specified, clean asynchronously removes the entire working tree for this bazel instance, which includes all bazel-created temporary and build output files, and stops the bazel server if it is running. When this command completes, it will be safe to execute new commands in the same client, even though the deletion may continue in the background.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--expunge">--expunge</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--async">--async</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>
</p></dd>
</dl>

<h2><a name="config">Config Options</a></h2>
<h2><a name="coverage">Coverage Options</a></h2>
<p>Inherits all options from <a href="#test">test</a>.</p>


<h2><a name="cquery">Cquery Options</a></h2>
<p>Inherits all options from <a href="#test">test</a>.</p>

<dl>Options relating to query output and semantics:
<dt id="cquery-flag--aspect_deps"><code id="aspect_deps"><a href="#cquery-flag--aspect_deps">--aspect_deps</a>=&lt;off, conservative or precise&gt;</code> default: "conservative"</dt>
<dd>
<p>How to resolve aspect dependencies when the output format is one of {xml,proto,record}. 'off' means no aspect dependencies are resolved, 'conservative' (the default) means all declared aspect dependencies are added regardless of whether they are given the rule class of direct dependencies, 'precise' means that only those aspects are added that are possibly active given the rule class of the direct dependencies. Note that precise mode requires loading other packages to evaluate a single target thus making it slower than the other modes. Also note that even precise mode is not completely precise: the decision whether to compute an aspect is decided in the analysis phase, which is not run during 'bazel query'.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="cquery-flag--consistent_labels"><code id="consistent_labels"><a href="#cquery-flag--consistent_labels">--[no]consistent_labels</a></code> default: "false"</dt>
<dd>
<p>If enabled, every query command emits labels as if by the Starlark &lt;code&gt;str&lt;/code&gt; function applied to a &lt;code&gt;Label&lt;/code&gt; instance. This is useful for tools that need to match the output of different query commands and/or labels emitted by rules. If not enabled, output formatters are free to emit apparent repository names (relative to the main repository) instead to make the output more readable.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--experimental_explicit_aspects"><code id="experimental_explicit_aspects"><a href="#cquery-flag--experimental_explicit_aspects">--[no]experimental_explicit_aspects</a></code> default: "false"</dt>
<dd>
<p>aquery, cquery: whether to include aspect-generated actions in the output. query: no-op (aspects are always followed).</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--graph:factored"><code id="graph:factored"><a href="#cquery-flag--graph:factored">--[no]graph:factored</a></code> default: "true"</dt>
<dd>
<p>If true, then the graph will be emitted 'factored', i.e. topologically-equivalent nodes will be merged together and their labels concatenated. This option is only applicable to --output=graph.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--graph:node_limit"><code id="graph:node_limit"><a href="#cquery-flag--graph:node_limit">--graph:node_limit</a>=&lt;an integer&gt;</code> default: "512"</dt>
<dd>
<p>The maximum length of the label string for a graph node in the output.  Longer labels will be truncated; -1 means no truncation.  This option is only applicable to --output=graph.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--implicit_deps"><code id="implicit_deps"><a href="#cquery-flag--implicit_deps">--[no]implicit_deps</a></code> default: "true"</dt>
<dd>
<p>If enabled, implicit dependencies will be included in the dependency graph over which the query operates. An implicit dependency is one that is not explicitly specified in the BUILD file but added by bazel. For cquery, this option controls filtering resolved toolchains.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="cquery-flag--include_aspects"><code id="include_aspects"><a href="#cquery-flag--include_aspects">--[no]include_aspects</a></code> default: "true"</dt>
<dd>
<p>aquery, cquery: whether to include aspect-generated actions in the output. query: no-op (aspects are always followed).</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--incompatible_package_group_includes_double_slash"><code id="incompatible_package_group_includes_double_slash"><a href="#cquery-flag--incompatible_package_group_includes_double_slash">--[no]incompatible_package_group_includes_double_slash</a></code> default: "true"</dt>
<dd>
<p>If enabled, when outputting package_group's <code>packages</code> attribute, the leading <code>//</code> will not be omitted.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="cquery-flag--infer_universe_scope"><code id="infer_universe_scope"><a href="#cquery-flag--infer_universe_scope">--[no]infer_universe_scope</a></code> default: "false"</dt>
<dd>
<p>If set and --universe_scope is unset, then a value of --universe_scope will be inferred as the list of unique target patterns in the query expression. Note that the --universe_scope value inferred for a query expression that uses universe-scoped functions (e.g.<code>allrdeps</code>) may not be what you want, so you should use this option only if you know what you are doing. See https://bazel.build/reference/query#sky-query for details and examples. If --universe_scope is set, then this option's value is ignored. Note: this option applies only to <code>query</code> (i.e. not <code>cquery</code>).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="cquery-flag--line_terminator_null"><code id="line_terminator_null"><a href="#cquery-flag--line_terminator_null">--[no]line_terminator_null</a></code> default: "false"</dt>
<dd>
<p>Whether each format is terminated with \0 instead of newline.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--nodep_deps"><code id="nodep_deps"><a href="#cquery-flag--nodep_deps">--[no]nodep_deps</a></code> default: "true"</dt>
<dd>
<p>If enabled, deps from &quot;nodep&quot; attributes will be included in the dependency graph over which the query operates. A common example of a &quot;nodep&quot; attribute is &quot;visibility&quot;. Run and parse the output of <code>info build-language</code> to learn about all the &quot;nodep&quot; attributes in the build language.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="cquery-flag--output"><code id="output"><a href="#cquery-flag--output">--output</a>=&lt;a string&gt;</code> default: "label"</dt>
<dd>
<p>The format in which the cquery results should be printed. Allowed values for cquery are: label, label_kind, textproto, transitions, proto, streamed_proto, jsonproto. If you select 'transitions', you also have to specify the --transitions=(lite|full) option.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--output_file"><code id="output_file"><a href="#cquery-flag--output_file">--output_file</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>When specified, query results will be written directly to this file, and nothing will be printed to Bazel's standard output stream (stdout). In benchmarks, this is generally faster than &lt;code&gt;bazel query &amp;gt; file&lt;/code&gt;.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--proto:default_values"><code id="proto:default_values"><a href="#cquery-flag--proto:default_values">--[no]proto:default_values</a></code> default: "true"</dt>
<dd>
<p>If true, attributes whose value is not explicitly specified in the BUILD file are included; otherwise they are omitted. This option is applicable to --output=proto</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--proto:definition_stack"><code id="proto:definition_stack"><a href="#cquery-flag--proto:definition_stack">--[no]proto:definition_stack</a></code> default: "false"</dt>
<dd>
<p>Populate the definition_stack proto field, which records for each rule instance the Starlark call stack at the moment the rule's class was defined.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--proto:flatten_selects"><code id="proto:flatten_selects"><a href="#cquery-flag--proto:flatten_selects">--[no]proto:flatten_selects</a></code> default: "true"</dt>
<dd>
<p>If enabled, configurable attributes created by select() are flattened. For list types the flattened representation is a list containing each value of the select map exactly once. Scalar types are flattened to null.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="cquery-flag--proto:include_attribute_source_aspects"><code id="proto:include_attribute_source_aspects"><a href="#cquery-flag--proto:include_attribute_source_aspects">--[no]proto:include_attribute_source_aspects</a></code> default: "false"</dt>
<dd>
<p>Populate the source_aspect_name proto field of each Attribute with the source aspect that the attribute came from (empty string if it did not).</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--proto:include_configurations"><code id="proto:include_configurations"><a href="#cquery-flag--proto:include_configurations">--[no]proto:include_configurations</a></code> default: "true"</dt>
<dd>
<p>if enabled, proto output will include information about configurations. When disabled,cquery proto output format resembles query output format.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="cquery-flag--proto:include_starlark_rule_env"><code id="proto:include_starlark_rule_env"><a href="#cquery-flag--proto:include_starlark_rule_env">--[no]proto:include_starlark_rule_env</a></code> default: "true"</dt>
<dd>
<p>Use the starlark environment in the value of the generated $internal_attr_hash attribute. This ensures that the starlark rule definition (and its transitive imports) are part of this identifier.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--proto:include_synthetic_attribute_hash"><code id="proto:include_synthetic_attribute_hash"><a href="#cquery-flag--proto:include_synthetic_attribute_hash">--[no]proto:include_synthetic_attribute_hash</a></code> default: "false"</dt>
<dd>
<p>Whether or not to calculate and populate the $internal_attr_hash attribute.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--proto:instantiation_stack"><code id="proto:instantiation_stack"><a href="#cquery-flag--proto:instantiation_stack">--[no]proto:instantiation_stack</a></code> default: "false"</dt>
<dd>
<p>Populate the instantiation call stack of each rule. Note that this requires the stack to be present</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--proto:locations"><code id="proto:locations"><a href="#cquery-flag--proto:locations">--[no]proto:locations</a></code> default: "true"</dt>
<dd>
<p>Whether to output location information in proto output at all.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--proto:output_rule_attrs"><code id="proto:output_rule_attrs"><a href="#cquery-flag--proto:output_rule_attrs">--proto:output_rule_attrs</a>=&lt;comma-separated list of options&gt;</code> default: "all"</dt>
<dd>
<p>Comma separated list of attributes to include in output. Defaults to all attributes. Set to empty string to not output any attribute. This option is applicable to --output=proto.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--proto:rule_classes"><code id="proto:rule_classes"><a href="#cquery-flag--proto:rule_classes">--[no]proto:rule_classes</a></code> default: "false"</dt>
<dd>
<p>Populate the rule_class_key field of each rule; and for the first rule with a given rule_class_key, also populate its rule_class_info proto field. The rule_class_key field uniquely identifies a rule class, and the rule_class_info field is a Stardoc-format rule class API definition.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--proto:rule_inputs_and_outputs"><code id="proto:rule_inputs_and_outputs"><a href="#cquery-flag--proto:rule_inputs_and_outputs">--[no]proto:rule_inputs_and_outputs</a></code> default: "true"</dt>
<dd>
<p>Whether or not to populate the rule_input and rule_output fields.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--query_file"><code id="query_file"><a href="#cquery-flag--query_file">--query_file</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>If set, query will read the query from the file named here, rather than on the command line. It is an error to specify a file here as well as a command-line query.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="cquery-flag--relative_locations"><code id="relative_locations"><a href="#cquery-flag--relative_locations">--[no]relative_locations</a></code> default: "false"</dt>
<dd>
<p>If true, the location of BUILD files in xml and proto outputs will be relative. By default, the location output is an absolute path and will not be consistent across machines. You can set this option to true to have a consistent result across machines.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--show_config_fragments"><code id="show_config_fragments"><a href="#cquery-flag--show_config_fragments">--show_config_fragments</a>=&lt;off, direct or transitive&gt;</code> default: "off"</dt>
<dd>
<p>Shows the configuration fragments required by a rule and its transitive dependencies. This can be useful for evaluating how much a configured target graph can be trimmed.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="cquery-flag--starlark:expr"><code id="starlark:expr"><a href="#cquery-flag--starlark:expr">--starlark:expr</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>A Starlark expression to format each configured target in cquery's --output=starlark mode. The configured target is bound to 'target'. If neither --starlark:expr nor --starlark:file is specified, this option will default to 'str(target.label)'. It is an error to specify both --starlark:expr and --starlark:file.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--starlark:file"><code id="starlark:file"><a href="#cquery-flag--starlark:file">--starlark:file</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The name of a file that defines a Starlark function called 'format', of one argument, that is applied to each configured target to format it as a string. It is an error to specify both --starlark:expr and --starlark:file. See help for --output=starlark for additional detail.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="cquery-flag--tool_deps"><code id="tool_deps"><a href="#cquery-flag--tool_deps">--[no]tool_deps</a></code> default: "true"</dt>
<dd>
<p>Query: If disabled, dependencies on 'exec configuration' will not be included in the dependency graph over which the query operates. An 'exec configuration' dependency edge, such as the one from any 'proto_library' rule to the Protocol Compiler, usually points to a tool executed during the build rather than a part of the same 'target' program.
Cquery: If disabled, filters out all configured targets which cross an execution transition from the top-level target that discovered this configured target. That means if the top-level target is in the target configuration, only configured targets also in the target configuration will be returned. If the top-level target is in the exec configuration, only exec configured targets will be returned. This option will NOT exclude resolved toolchains.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="cquery-flag--transitions"><code id="transitions"><a href="#cquery-flag--transitions">--transitions</a>=&lt;full, lite or none&gt;</code> default: "none"</dt>
<dd>
<p>The format in which cquery will print transition information.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="cquery-flag--universe_scope"><code id="universe_scope"><a href="#cquery-flag--universe_scope">--universe_scope</a>=&lt;comma-separated list of options&gt;</code> default: ""</dt>
<dd>
<p>A comma-separated set of target patterns (additive and subtractive). The query may be performed in the universe defined by the transitive closure of the specified targets. This option is used for the query and cquery commands.
For cquery, the input to this option is the targets all answers are built under and so this option may affect configurations and transitions. If this option is not specified, the top-level targets are assumed to be the targets parsed from the query expression. Note: For cquery, not specifying this option may cause the build to break if targets parsed from the query expression are not buildable with top-level options.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
</dl>

<dl>Options that control build execution:
<dt id="flag--experimental_persistent_aar_extractor"><code><a href="#flag--experimental_persistent_aar_extractor">--[no]experimental_persistent_aar_extractor</a></code> default: "false"</dt>
<dd>
<p>Enable persistent aar extractor by using workers.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_remotable_source_manifests"><code><a href="#flag--experimental_remotable_source_manifests">--[no]experimental_remotable_source_manifests</a></code> default: "false"</dt>
<dd>
<p>Whether to make source manifest actions remotable</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_split_coverage_postprocessing"><code><a href="#flag--experimental_split_coverage_postprocessing">--[no]experimental_split_coverage_postprocessing</a></code> default: "false"</dt>
<dd>
<p>If true, then Bazel will run coverage postprocessing for test in a new spawn.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_strict_fileset_output"><code><a href="#flag--experimental_strict_fileset_output">--[no]experimental_strict_fileset_output</a></code> default: "false"</dt>
<dd>
<p>If this option is enabled, filesets will treat all output artifacts as regular files. They will not traverse directories or be sensitive to symlinks.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--incompatible_modify_execution_info_additive"><code><a href="#flag--incompatible_modify_execution_info_additive">--[no]incompatible_modify_execution_info_additive</a></code> default: "true"</dt>
<dd>
<p>When enabled, passing multiple <code>--modify_execution_info</code> flags is additive.
When disabled, only the last flag is taken into account.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--modify_execution_info"><code><a href="#flag--modify_execution_info">--modify_execution_info</a>=&lt;regex=[+-]key,regex=[+-]key,...&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Add or remove keys from an action's execution info based on action mnemonic.
Applies only to actions which support execution info. Many common actions
support execution info, e.g. Genrule, CppCompile, Javac, StarlarkAction,
TestRunner. When specifying multiple values, order matters because
many regexes may apply to the same mnemonic.</p>
<p>Syntax: <code>regex=[+-]key,regex=[+-]key,...</code>.</p>
<p>Examples:</p>
<ul>
<li><code>.*=+x,.*=-y,.*=+z</code> adds <code>x</code> and <code>z</code> to, and removes <code>y</code> from, the execution info for all actions.</li>
<li><code>Genrule=+requires-x</code> adds <code>requires-x</code> to the execution info for all Genrule actions.</li>
<li><code>(?!Genrule).*=-requires-x</code> removes <code>requires-x</code> from the execution info for all non-Genrule actions.</li>
</ul>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--persistent_android_dex_desugar"><code><a href="#flag--persistent_android_dex_desugar">--persistent_android_dex_desugar</a></code></dt>
<dd>
<p>Enable persistent Android dex and desugar actions by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_android_dex_desugar">--internal_persistent_android_dex_desugar</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=Desugar=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=DexBuilder=worker</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_android_resource_processor"><code><a href="#flag--persistent_android_resource_processor">--persistent_android_resource_processor</a></code></dt>
<dd>
<p>Enable persistent Android resource processor by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_busybox_tools">--internal_persistent_busybox_tools</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AaptPackage=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceParser=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceValidator=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceCompiler=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=RClassGenerator=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceLink=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidAapt2=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidAssetMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidCompiledResourceMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=ManifestMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidManifestMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=Aapt2Optimize=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AARGenerator=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=ProcessDatabinding=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=GenerateDataBindingBaseClasses=worker</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_multiplex_android_dex_desugar"><code><a href="#flag--persistent_multiplex_android_dex_desugar">--persistent_multiplex_android_dex_desugar</a></code></dt>
<dd>
<p>Enable persistent multiplexed Android dex and desugar actions by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_android_dex_desugar">--persistent_android_dex_desugar</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_multiplex_android_dex_desugar">--internal_persistent_multiplex_android_dex_desugar</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_multiplex_android_resource_processor"><code><a href="#flag--persistent_multiplex_android_resource_processor">--persistent_multiplex_android_resource_processor</a></code></dt>
<dd>
<p>Enable persistent multiplexed Android resource processor by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_android_resource_processor">--persistent_android_resource_processor</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AaptPackage=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceParser=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceValidator=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceCompiler=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=RClassGenerator=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceLink=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidAapt2=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidAssetMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidCompiledResourceMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=ManifestMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidManifestMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=Aapt2Optimize=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AARGenerator=+supports-multiplex-workers</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_multiplex_android_tools"><code><a href="#flag--persistent_multiplex_android_tools">--persistent_multiplex_android_tools</a></code></dt>
<dd>
<p>Enable persistent and multiplexed Android tools (dexing, desugaring, resource processing).</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_multiplex_busybox_tools">--internal_persistent_multiplex_busybox_tools</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_multiplex_android_resource_processor">--persistent_multiplex_android_resource_processor</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_multiplex_android_dex_desugar">--persistent_multiplex_android_dex_desugar</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--use_target_platform_for_tests"><code><a href="#flag--use_target_platform_for_tests">--[no]use_target_platform_for_tests</a></code> default: "false"</dt>
<dd>
<p>If true, use the target platform for running tests rather than the test exec group.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
</dl>
<dl>Options that configure the toolchain used for action execution:
<dt id="flag--android_compiler"><code><a href="#flag--android_compiler">--android_compiler</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The Android target compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--android_manifest_merger"><code><a href="#flag--android_manifest_merger">--android_manifest_merger</a>=&lt;legacy, android or force_android&gt;</code> default: "android"</dt>
<dd>
<p>Selects the manifest merger to use for android_binary rules. Flag to help the transition to the Android manifest merger from the legacy merger.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--android_platforms"><code><a href="#flag--android_platforms">--android_platforms</a>=&lt;a build target label&gt;</code> default: ""</dt>
<dd>
<p>Sets the platforms that android_binary targets use. If multiple platforms are specified, then the binary is a fat APKs, which contains native binaries for each specified target platform.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--cc_output_directory_tag"><code><a href="#flag--cc_output_directory_tag">--cc_output_directory_tag</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Specifies a suffix to be added to the configuration directory.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--compiler"><code><a href="#flag--compiler">--compiler</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The C++ compiler to use for compiling the target.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--coverage_output_generator"><code><a href="#flag--coverage_output_generator">--coverage_output_generator</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/test:lcov_merger"</dt>
<dd>
<p>Location of the binary that is used to postprocess raw coverage reports. This must
be a binary target. Defaults to <code>@bazel_tools//tools/test:lcov_merger</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--coverage_report_generator"><code><a href="#flag--coverage_report_generator">--coverage_report_generator</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/test:coverage_report_generator"</dt>
<dd>
<p>Location of the binary that is used to generate coverage reports. This must
be a binary target. Defaults to <code>@bazel_tools//tools/test:coverage_report_generator</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--coverage_support"><code><a href="#flag--coverage_support">--coverage_support</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/test:coverage_support"</dt>
<dd>
<p>Location of support files that are required on the inputs of every test action
that collects code coverage. Defaults to <code>//tools/test:coverage_support</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--custom_malloc"><code><a href="#flag--custom_malloc">--custom_malloc</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies a custom malloc implementation. This setting overrides malloc attributes in build rules.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--experimental_include_xcode_execution_requirements"><code><a href="#flag--experimental_include_xcode_execution_requirements">--[no]experimental_include_xcode_execution_requirements</a></code> default: "false"</dt>
<dd>
<p>If set, add a &quot;requires-xcode:{version}&quot; execution requirement to every Xcode action.  If the Xcode version has a hyphenated label,  also add a &quot;requires-xcode-label:{version_label}&quot; execution requirement.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_prefer_mutual_xcode"><code><a href="#flag--experimental_prefer_mutual_xcode">--[no]experimental_prefer_mutual_xcode</a></code> default: "true"</dt>
<dd>
<p>If true, use the most recent Xcode that is available both locally and remotely. If false, or if there are no mutual available versions, use the local Xcode version selected via xcode-select.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--extra_execution_platforms"><code><a href="#flag--extra_execution_platforms">--extra_execution_platforms</a>=&lt;comma-separated list of options&gt;</code> default: ""</dt>
<dd>
<p>The platforms that are available as execution platforms to run actions.
Platforms can be specified by exact target, or as a target pattern.
These platforms will be considered before those declared in the <code>WORKSPACE</code> file by
<code>register_execution_platforms()</code>. This option may only be set once; later
instances will override earlier flag settings.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--extra_toolchains"><code><a href="#flag--extra_toolchains">--extra_toolchains</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The toolchain rules to be considered during toolchain resolution.
Toolchains can be specified by exact target, or as a target pattern.
These toolchains will be considered before those declared in the <code>WORKSPACE</code> file
by <code>register_toolchains()</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--grte_top"><code><a href="#flag--grte_top">--grte_top</a>=&lt;a label&gt;</code> default: see description</dt>
<dd>
<p>A label to a checked-in libc library. The default value is selected by the crosstool toolchain, and you almost never need to override it.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_compiler"><code><a href="#flag--host_compiler">--host_compiler</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>No-op flag. Will be removed in a future release.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--host_grte_top"><code><a href="#flag--host_grte_top">--host_grte_top</a>=&lt;a label&gt;</code> default: see description</dt>
<dd>
<p>If specified, this setting overrides the libc top-level directory (--grte_top) for the exec configuration.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_platform"><code><a href="#flag--host_platform">--host_platform</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools:host_platform"</dt>
<dd>
<p>The label of a platform rule that describes the host system.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--incompatible_bazel_test_exec_run_under"><code><a href="#flag--incompatible_bazel_test_exec_run_under">--[no]incompatible_bazel_test_exec_run_under</a></code> default: "true"</dt>
<dd>
<p>If enabled, <code>bazel test --run_under=//:runner</code> builds <code>//:runner</code> in the exec
configuration. If disabled, it builds <code>//:runner</code> in the target configuration.
Bazel executes tests on exec machines, so the former is more correct. This
doesn't affect <code>bazel run</code>, which always builds <code>--run_under=//foo</code> in the
target configuration.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_builtin_objc_strip_action"><code><a href="#flag--incompatible_builtin_objc_strip_action">--[no]incompatible_builtin_objc_strip_action</a></code> default: "true"</dt>
<dd>
<p>Whether to emit a strip action as part of objc linking.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_dont_enable_host_nonhost_crosstool_features"><code><a href="#flag--incompatible_dont_enable_host_nonhost_crosstool_features">--[no]incompatible_dont_enable_host_nonhost_crosstool_features</a></code> default: "true"</dt>
<dd>
<p>If true, Bazel will not enable 'host' and 'nonhost' features in the c++ toolchain (see https://github.com/bazelbuild/bazel/issues/7407 for more information).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_enable_apple_toolchain_resolution"><code><a href="#flag--incompatible_enable_apple_toolchain_resolution">--[no]incompatible_enable_apple_toolchain_resolution</a></code> default: "false"</dt>
<dd>
<p>Use toolchain resolution to select the Apple SDK for apple rules (Starlark and native)</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_remove_legacy_whole_archive"><code><a href="#flag--incompatible_remove_legacy_whole_archive">--[no]incompatible_remove_legacy_whole_archive</a></code> default: "true"</dt>
<dd>
<p>If true, Bazel will not link library dependencies as whole archive by default (see https://github.com/bazelbuild/bazel/issues/7362 for migration instructions).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_strip_executable_safely"><code><a href="#flag--incompatible_strip_executable_safely">--[no]incompatible_strip_executable_safely</a></code> default: "false"</dt>
<dd>
<p>If true, strip action for executables will use flag -x, which does not break dynamic symbol resolution.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--interface_shared_objects"><code><a href="#flag--interface_shared_objects">--[no]interface_shared_objects</a></code> default: "true"</dt>
<dd>
<p>Use interface shared objects if supported by the toolchain. All ELF toolchains currently support this setting.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ios_sdk_version"><code><a href="#flag--ios_sdk_version">--ios_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the iOS SDK to use to build iOS applications. If unspecified, uses the default iOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--macos_sdk_version"><code><a href="#flag--macos_sdk_version">--macos_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the macOS SDK to use to build macOS applications. If unspecified, uses the default macOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--minimum_os_version"><code><a href="#flag--minimum_os_version">--minimum_os_version</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The minimum OS version which your compilation targets.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--platform_mappings"><code><a href="#flag--platform_mappings">--platform_mappings</a>=&lt;a main workspace-relative path&gt;</code> default: ""</dt>
<dd>
<p>The location of a mapping file that describes which platform to use if none is set or
which flags to set when a platform already exists. Must be relative to the main
workspace root. Defaults to <code>platform_mappings</code> (a file directly under the
workspace root).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--platforms"><code><a href="#flag--platforms">--platforms</a>=&lt;a build target label&gt;</code> default: ""</dt>
<dd>
<p>The labels of the platform rules describing the target platforms for the current command.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--python_path"><code><a href="#flag--python_path">--python_path</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The absolute path of the Python interpreter invoked to run Python targets on the
target platform. Deprecated; disabled by <code>--incompatible_use_python_toolchains</code>.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--tvos_sdk_version"><code><a href="#flag--tvos_sdk_version">--tvos_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the tvOS SDK to use to build tvOS applications. If unspecified, uses the default tvOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--use_platforms_in_apple_crosstool_transition"><code><a href="#flag--use_platforms_in_apple_crosstool_transition">--[no]use_platforms_in_apple_crosstool_transition</a></code> default: "false"</dt>
<dd>
<p>Makes apple_crosstool_transition fall back to using the value of <code>--platforms</code> flag instead of legacy <code>--cpu</code> when needed.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--watchos_sdk_version"><code><a href="#flag--watchos_sdk_version">--watchos_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the watchOS SDK to use to build watchOS applications. If unspecified, uses the default watchOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--xcode_version"><code><a href="#flag--xcode_version">--xcode_version</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>If specified, uses Xcode of the given version for relevant build actions. If unspecified, uses the executor default version of Xcode.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--xcode_version_config"><code><a href="#flag--xcode_version_config">--xcode_version_config</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/cpp:host_xcodes"</dt>
<dd>
<p>The label of the xcode_config rule to be used for selecting the Xcode version in the build configuration.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
</dl>
<dl>Options that control the output of the command:
<dt id="flag--apple_generate_dsym"><code><a href="#flag--apple_generate_dsym">--[no]apple_generate_dsym</a></code> default: "false"</dt>
<dd>
<p>Whether to generate debug symbol(.dSYM) file(s).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--build_runfile_links"><code><a href="#flag--build_runfile_links">--[no]build_runfile_links</a></code> default: "true"</dt>
<dd>
<p>If true, build runfiles symlink forests for all targets.  If false, write them only when required by a local action, test or run command.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--build_runfile_manifests"><code><a href="#flag--build_runfile_manifests">--[no]build_runfile_manifests</a></code> default: "true"</dt>
<dd>
<p>If true, write runfiles manifests for all targets. If false, omit them. Local tests will fail to run when false.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--build_test_dwp"><code><a href="#flag--build_test_dwp">--[no]build_test_dwp</a></code> default: "false"</dt>
<dd>
<p>If enabled, when building C++ tests statically and with fission the .dwp file  for the test binary will be automatically built as well.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cc_proto_library_header_suffixes"><code><a href="#flag--cc_proto_library_header_suffixes">--cc_proto_library_header_suffixes</a>=&lt;comma-separated set of options&gt;</code> default: ".pb.h"</dt>
<dd>
<p>Sets the suffixes of header files that a cc_proto_library creates.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--cc_proto_library_source_suffixes"><code><a href="#flag--cc_proto_library_source_suffixes">--cc_proto_library_source_suffixes</a>=&lt;comma-separated set of options&gt;</code> default: ".pb.cc"</dt>
<dd>
<p>Sets the suffixes of source files that a cc_proto_library creates.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--experimental_proto_descriptor_sets_include_source_info"><code><a href="#flag--experimental_proto_descriptor_sets_include_source_info">--[no]experimental_proto_descriptor_sets_include_source_info</a></code> default: "false"</dt>
<dd>
<p>Run extra actions for alternative Java api versions in a proto_library.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_save_feature_state"><code><a href="#flag--experimental_save_feature_state">--[no]experimental_save_feature_state</a></code> default: "false"</dt>
<dd>
<p>Save the state of enabled and requested feautres as an output of compilation.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--fission"><code><a href="#flag--fission">--fission</a>=&lt;a set of compilation modes&gt;</code> default: "no"</dt>
<dd>
<p>Specifies which compilation modes use fission for C++ compilations and links.  May be any combination of {'fastbuild', 'dbg', 'opt'} or the special values 'yes'  to enable all modes and 'no' to disable all modes.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--incompatible_always_include_files_in_data"><code><a href="#flag--incompatible_always_include_files_in_data">--[no]incompatible_always_include_files_in_data</a></code> default: "true"</dt>
<dd>
<p>If true, native rules add <code>DefaultInfo.files</code> of data dependencies to their runfiles,
which matches the recommended behavior for Starlark rules (<a href="https://bazel.build/extending/rules#runfiles_features_to_avoid">runfiles features to avoid</a>).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_compact_repo_mapping_manifest"><code><a href="#flag--incompatible_compact_repo_mapping_manifest">--[no]incompatible_compact_repo_mapping_manifest</a></code> default: "false"</dt>
<dd>
<p>If enabled, the <code>{binary}.repo_mapping</code> file emits a module extension's repo mapping
only once instead of once for each repo generated by the extension that
contributes runfiles.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_disable_select_on"><code><a href="#flag--incompatible_disable_select_on">--incompatible_disable_select_on</a>=&lt;comma-separated set of options&gt;</code> default: ""</dt>
<dd>
<p>List of flags for which the use in <code>select()</code> is disabled.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--incompatible_filegroup_runfiles_for_data"><code><a href="#flag--incompatible_filegroup_runfiles_for_data">--[no]incompatible_filegroup_runfiles_for_data</a></code> default: "true"</dt>
<dd>
<p>If true, runfiles of targets listed in the srcs attribute are available to targets that consume the filegroup as a data dependency.</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--objc_generate_linkmap"><code><a href="#flag--objc_generate_linkmap">--[no]objc_generate_linkmap</a></code> default: "false"</dt>
<dd>
<p>Specifies whether to generate a linkmap file.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--save_temps"><code><a href="#flag--save_temps">--[no]save_temps</a></code> default: "false"</dt>
<dd>
<p>If set, temporary outputs from gcc will be saved.  These include .s files (assembler code), .i files (preprocessed C) and .ii files (preprocessed C++).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
</dl>
<dl>Options that let the user configure the intended output, affecting its value, as opposed to its existence:
<dt id="flag--action_env"><code><a href="#flag--action_env">--action_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the set of environment variables available to actions with target
configuration. Variables can be either specified by <code>name</code>, in which case
the value will be taken from the invocation environment, by the <code>name=value</code>
pair which sets the value independent of the invocation environment, or by
<code>=name</code>, which unsets the variable of that name. This option can be used
multiple times; for options given for the same variable, the latest wins,
options for different variables accumulate.</p>
<p>Note that unless <code>--incompatible_repo_env_ignores_action_env</code> is true, all <code>name=value</code>
pairs will be available to repository rules.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--allowed_cpu_values"><code><a href="#flag--allowed_cpu_values">--allowed_cpu_values</a>=&lt;comma-separated set of options&gt;</code> default: ""</dt>
<dd>
<p>Allowed values for the <code>--cpu</code> flag.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--android_databinding_use_androidx"><code><a href="#flag--android_databinding_use_androidx">--[no]android_databinding_use_androidx</a></code> default: "true"</dt>
<dd>
<p>Generate AndroidX-compatible data-binding files. This is only used with databinding v2. This flag is a no-op.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--android_databinding_use_v3_4_args"><code><a href="#flag--android_databinding_use_v3_4_args">--[no]android_databinding_use_v3_4_args</a></code> default: "true"</dt>
<dd>
<p>Use android databinding v2 with 3.4.0 argument. This flag is a no-op.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--android_dynamic_mode"><code><a href="#flag--android_dynamic_mode">--android_dynamic_mode</a>=&lt;off, default or fully&gt;</code> default: "off"</dt>
<dd>
<p>Determines whether C++ deps of Android rules will be linked dynamically when a cc_binary does not explicitly create a shared library. 'default' means bazel will choose whether to link dynamically.  'fully' means all libraries will be linked dynamically. 'off' means that all libraries will be linked in mostly static mode.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--android_manifest_merger_order"><code><a href="#flag--android_manifest_merger_order">--android_manifest_merger_order</a>=&lt;alphabetical, alphabetical_by_configuration or dependency&gt;</code> default: "alphabetical"</dt>
<dd>
<p>Sets the order of manifests passed to the manifest merger for Android binaries. ALPHABETICAL means manifests are sorted by path relative to the execroot. ALPHABETICAL_BY_CONFIGURATION means manifests are sorted by paths relative to the configuration directory within the output directory. DEPENDENCY means manifests are ordered with each library's manifest coming before the manifests of its dependencies.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--android_resource_shrinking"><code><a href="#flag--android_resource_shrinking">--[no]android_resource_shrinking</a></code> default: "false"</dt>
<dd>
<p>Enables resource shrinking for android_binary APKs that use ProGuard.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--build_python_zip"><code><a href="#flag--build_python_zip">--[no]build_python_zip</a></code> default: "auto"</dt>
<dd>
<p>Build python executable zip; on on Windows, off on other platforms</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--catalyst_cpus"><code><a href="#flag--catalyst_cpus">--catalyst_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple Catalyst binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--collect_code_coverage"><code><a href="#flag--collect_code_coverage">--[no]collect_code_coverage</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will instrument code (using offline instrumentation where
possible) and will collect coverage information during tests. Only targets that
match <code>--instrumentation_filter</code> will be affected. Usually this option should
not be specified directly - <code>bazel coverage</code> command should be used instead.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--compilation_mode"><code><a href="#flag--compilation_mode">--compilation_mode</a>=&lt;fastbuild, dbg or opt&gt;</code> [<code>-c</code>] default: "fastbuild"</dt>
<dd>
<p>Specify the mode the binary will be built in. Values: <code>fastbuild</code>, <code>dbg</code>, <code>opt</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--conlyopt"><code><a href="#flag--conlyopt">--conlyopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to gcc when compiling C source files.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--copt"><code><a href="#flag--copt">--copt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to gcc.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cpu"><code><a href="#flag--cpu">--cpu</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Deprecated: this flag is not used internally by Blaze although there are legacy platform
mappings to allow for backwards compatibility. Do not use this flag, instead use
<code>--platforms</code> with an appropriate platform definition.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cs_fdo_absolute_path"><code><a href="#flag--cs_fdo_absolute_path">--cs_fdo_absolute_path</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Use CSFDO profile information to optimize compilation. Specify the absolute path name of the zip file containing the profile file, a raw or an indexed LLVM profile file.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cs_fdo_instrument"><code><a href="#flag--cs_fdo_instrument">--cs_fdo_instrument</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Generate binaries with context sensitive FDO instrumentation. With Clang/LLVM compiler, it also accepts the directory name under which the raw profile file(s) will be dumped at runtime.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cs_fdo_profile"><code><a href="#flag--cs_fdo_profile">--cs_fdo_profile</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The cs_fdo_profile representing the context sensitive profile to be used for optimization.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cxxopt"><code><a href="#flag--cxxopt">--cxxopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to gcc when compiling C++ source files.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--define"><code><a href="#flag--define">--define</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Each <code>--define</code> option specifies an assignment for a build variable.
In case of multiple values for a variable, the last one wins.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--dynamic_mode"><code><a href="#flag--dynamic_mode">--dynamic_mode</a>=&lt;off, default or fully&gt;</code> default: "default"</dt>
<dd>
<p>Determines whether C++ binaries will be linked dynamically.  'default' means Bazel will choose whether to link dynamically.  'fully' means all libraries will be linked dynamically. 'off' means that all libraries will be linked in mostly static mode.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--enable_propeller_optimize_absolute_paths"><code><a href="#flag--enable_propeller_optimize_absolute_paths">--[no]enable_propeller_optimize_absolute_paths</a></code> default: "true"</dt>
<dd>
<p>If set, any use of absolute paths for propeller optimize will raise an error.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--enable_remaining_fdo_absolute_paths"><code><a href="#flag--enable_remaining_fdo_absolute_paths">--[no]enable_remaining_fdo_absolute_paths</a></code> default: "true"</dt>
<dd>
<p>If set, any use of absolute paths for FDO will raise an error.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--enable_runfiles"><code><a href="#flag--enable_runfiles">--[no]enable_runfiles</a></code> default: "auto"</dt>
<dd>
<p>Enable runfiles symlink tree; By default, it's off on Windows, on on other platforms.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--exec_aspects"><code><a href="#flag--exec_aspects">--exec_aspects</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of aspects to be applied to exec-configured targets, regardless of whether or not they are top-level targets. This is an experimental feature and is subject to change.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--experimental_action_listener"><code><a href="#flag--experimental_action_listener">--experimental_action_listener</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Deprecated in favor of aspects. Use <code>action_listener</code> to attach an <code>extra_action</code> to
existing build actions.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_compress_java_resources"><code><a href="#flag--experimental_android_compress_java_resources">--[no]experimental_android_compress_java_resources</a></code> default: "false"</dt>
<dd>
<p>Compress Java resources in APKs</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_databinding_v2"><code><a href="#flag--experimental_android_databinding_v2">--[no]experimental_android_databinding_v2</a></code> default: "true"</dt>
<dd>
<p>Use android databinding v2. This flag is a no-op.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_resource_shrinking"><code><a href="#flag--experimental_android_resource_shrinking">--[no]experimental_android_resource_shrinking</a></code> default: "false"</dt>
<dd>
<p>Enables resource shrinking for android_binary APKs that use ProGuard.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_rewrite_dexes_with_rex"><code><a href="#flag--experimental_android_rewrite_dexes_with_rex">--[no]experimental_android_rewrite_dexes_with_rex</a></code> default: "false"</dt>
<dd>
<p>use rex tool to rewrite dex files</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_collect_code_coverage_for_generated_files"><code><a href="#flag--experimental_collect_code_coverage_for_generated_files">--[no]experimental_collect_code_coverage_for_generated_files</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will also generate collect coverage information for generated files.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_objc_fastbuild_options"><code><a href="#flag--experimental_objc_fastbuild_options">--experimental_objc_fastbuild_options</a>=&lt;comma-separated list of options&gt;</code> default: "-O0,-DDEBUG=1"</dt>
<dd>
<p>Uses these strings as objc fastbuild compiler options.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--experimental_omitfp"><code><a href="#flag--experimental_omitfp">--[no]experimental_omitfp</a></code> default: "false"</dt>
<dd>
<p>If true, use libunwind for stack unwinding, and compile with -fomit-frame-pointer and -fasynchronous-unwind-tables.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_output_paths"><code><a href="#flag--experimental_output_paths">--experimental_output_paths</a>=&lt;off or strip&gt;</code> default: "off"</dt>
<dd>
<p>Which model to use for where in the output tree rules write their outputs, particularly
for multi-platform / multi-configuration builds. This is highly experimental. See
<a href="https://github.com/bazelbuild/bazel/issues/6526">GH-6526</a> for details. Starlark actions can opt into path mapping by adding the key
<code>supports-path-mapping</code> to the <code>execution_requirements</code> dict.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--experimental_override_platform_cpu_name"><code><a href="#flag--experimental_override_platform_cpu_name">--experimental_override_platform_cpu_name</a>=&lt;a &#39;label=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Each entry should be of the form <code>label=value</code> where label refers to a platform and values
is the desired shortname to override the platform's CPU name in <code>$(TARGET_CPU)</code>
make variable and output path. Only used when
<code>--experimental_platform_in_output_dir</code>, <code>--incompatible_target_cpu_from_platform</code> or
<code>--incompatible_bep_cpu_from_platform</code> is true. Has highest naming priority.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_platform_in_output_dir"><code><a href="#flag--experimental_platform_in_output_dir">--[no]experimental_platform_in_output_dir</a></code> default: "Auto"</dt>
<dd>
<p>If true, a shortname for the target platform is used in the output directory name
instead of the CPU. The exact scheme is experimental and subject to change:</p>
<ol>
<li>First, in the rare case the <code>--platforms</code> option does not have exactly one value, a
hash of the platforms option is used.</li>
<li>Next, if any shortname for the current platform was registered by
<code>--experimental_override_name_platform_in_output_dir</code>, then that shortname is used.</li>
<li>Then, if <code>--experimental_use_platforms_in_output_dir_legacy_heuristic</code> is set, use a
shortname based off the current platform Label.</li>
<li>Finally, a hash of the platform option is used as a last resort.</li>
</ol>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_py_binaries_include_label"><code><a href="#flag--experimental_py_binaries_include_label">--[no]experimental_py_binaries_include_label</a></code> default: "false"</dt>
<dd>
<p>py_binary targets include their label even when stamping is disabled.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_use_llvm_covmap"><code><a href="#flag--experimental_use_llvm_covmap">--[no]experimental_use_llvm_covmap</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will generate llvm-cov coverage map information rather than gcov when collect_code_coverage is enabled.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_use_platforms_in_output_dir_legacy_heuristic"><code><a href="#flag--experimental_use_platforms_in_output_dir_legacy_heuristic">--[no]experimental_use_platforms_in_output_dir_legacy_heuristic</a></code> default: "true"</dt>
<dd>
<p>Please only use this flag as part of a suggested migration or testing strategy. Note
that the heuristic has known deficiencies and it is suggested to migrate to
relying on just <code>--experimental_override_name_platform_in_output_dir</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--fdo_instrument"><code><a href="#flag--fdo_instrument">--fdo_instrument</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Generate binaries with FDO instrumentation. With Clang/LLVM compiler, it also accepts the directory name under which the raw profile file(s) will be dumped at runtime.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--fdo_optimize"><code><a href="#flag--fdo_optimize">--fdo_optimize</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Use FDO profile information to optimize compilation. Specify the name of a zip file containing a .gcda file tree, an afdo file containing an auto profile, or an LLVM profile file. This flag also accepts files specified as labels (e.g. <code>//foo/bar:file.afdo</code> - you may need to add an <code>exports_files</code> directive to the corresponding package) and labels pointing to <code>fdo_profile</code> targets. This flag will be superseded by the <code>fdo_profile</code> rule.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--fdo_prefetch_hints"><code><a href="#flag--fdo_prefetch_hints">--fdo_prefetch_hints</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use cache prefetch hints.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--fdo_profile"><code><a href="#flag--fdo_profile">--fdo_profile</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The fdo_profile representing the profile to be used for optimization.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--features"><code><a href="#flag--features">--features</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The given features will be enabled or disabled by default for targets built in the target configuration.
Specifying <code>-{feature}</code> will disable the feature. Negative features always override positive ones.
See also <code>--host_features</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--force_pic"><code><a href="#flag--force_pic">--[no]force_pic</a></code> default: "false"</dt>
<dd>
<p>If enabled, all C++ compilations produce position-independent code (&quot;-fPIC&quot;), links prefer PIC pre-built libraries over non-PIC libraries, and links produce position-independent executables (&quot;-pie&quot;).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_action_env"><code><a href="#flag--host_action_env">--host_action_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the set of environment variables available to actions with execution
configurations. Variables can be either specified by <code>name</code>, in which case the
value will be taken from the invocation environment, by the <code>name=value</code> pair
which sets the value independent of the invocation environment, or by
<code>=name</code>, which unsets the variable of that name. This option can
be used multiple times; for options given for the same variable, the latest
wins, options for different variables accumulate.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--host_compilation_mode"><code><a href="#flag--host_compilation_mode">--host_compilation_mode</a>=&lt;fastbuild, dbg or opt&gt;</code> default: "opt"</dt>
<dd>
<p>Specify the mode the tools used during the build will be built in. Values:
<code>fastbuild</code>, <code>dbg</code>, <code>opt</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--host_conlyopt"><code><a href="#flag--host_conlyopt">--host_conlyopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to the C compiler when compiling C (but not C++) source files in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_copt"><code><a href="#flag--host_copt">--host_copt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the C compiler for tools built in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_cpu"><code><a href="#flag--host_cpu">--host_cpu</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The host CPU.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_cxxopt"><code><a href="#flag--host_cxxopt">--host_cxxopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to C++ compiler for tools built in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_features"><code><a href="#flag--host_features">--host_features</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The given features will be enabled or disabled by default for targets built in the exec configuration.
Specifying <code>-{feature}</code> will disable the feature. Negative features always override positive ones.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_linkopt"><code><a href="#flag--host_linkopt">--host_linkopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to linker when linking tools in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_macos_minimum_os"><code><a href="#flag--host_macos_minimum_os">--host_macos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible macOS version for host targets. If unspecified, uses 'macos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--host_per_file_copt"><code><a href="#flag--host_per_file_copt">--host_per_file_copt</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths followed by an @ and a comma separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to selectively pass to the C/C++ compiler when compiling certain files in the exec configurations. This option can be passed multiple times. Syntax: regex_filter@option_1,option_2,...,option_n. Where regex_filter stands for a list of include and exclude regular expression patterns (Also see --instrumentation_filter). option_1 to option_n stand for arbitrary command line options. If an option contains a comma it has to be quoted with a backslash. Options can contain @. Only the first @ is used to split the string. Example: --host_per_file_copt=//foo/.*.cc,-//foo/bar.cc@-O0 adds the -O0 command line option to the gcc command line of all cc files in //foo/ except bar.cc.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--incompatible_auto_exec_groups"><code><a href="#flag--incompatible_auto_exec_groups">--[no]incompatible_auto_exec_groups</a></code> default: "false"</dt>
<dd>
<p>When enabled, an exec groups is automatically created for each toolchain used by a rule.
For this to work rule needs to specify <code>toolchain</code> parameter on its actions. For
more information, see <a href="https://github.com/bazelbuild/bazel/issues/17134">GH-17134</a>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_merge_genfiles_directory"><code><a href="#flag--incompatible_merge_genfiles_directory">--[no]incompatible_merge_genfiles_directory</a></code> default: "true"</dt>
<dd>
<p>If true, the genfiles directory is folded into the bin directory.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_target_cpu_from_platform"><code><a href="#flag--incompatible_target_cpu_from_platform">--[no]incompatible_target_cpu_from_platform</a></code> default: "true"</dt>
<dd>
<p>If specified, the value of the cpu constraint (<code>@platforms//cpu:cpu</code>) of
the target platform is used to set the <code>$(TARGET_CPU)</code> make variable.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--instrument_test_targets"><code><a href="#flag--instrument_test_targets">--[no]instrument_test_targets</a></code> default: "false"</dt>
<dd>
<p>When coverage is enabled, specifies whether to consider instrumenting test rules.
When set, test rules included by <code>--instrumentation_filter</code> are instrumented.
Otherwise, test rules are always excluded from coverage instrumentation.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--instrumentation_filter"><code><a href="#flag--instrumentation_filter">--instrumentation_filter</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths&gt;</code> default: "-/javatests[/:],-/test/java[/:]"</dt>
<dd>
<p>When coverage is enabled, only rules with names included by the
specified regex-based filter will be instrumented. Rules prefixed
with '-' are excluded instead. Note that only non-test rules are
instrumented unless <code>--instrument_test_targets</code> is enabled.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ios_minimum_os"><code><a href="#flag--ios_minimum_os">--ios_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible iOS version for target simulators and devices. If unspecified, uses 'ios_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--ios_multi_cpus"><code><a href="#flag--ios_multi_cpus">--ios_multi_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures to build an ios_application with. The result is a universal binary containing all specified architectures.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--legacy_whole_archive"><code><a href="#flag--legacy_whole_archive">--[no]legacy_whole_archive</a></code> default: "true"</dt>
<dd>
<p>Deprecated, superseded by --incompatible_remove_legacy_whole_archive (see https://github.com/bazelbuild/bazel/issues/7362 for details). When on, use --whole-archive for cc_binary rules that have linkshared=True and either linkstatic=True or '-static' in linkopts. This is for backwards compatibility only. A better alternative is to use alwayslink=1 where required.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_DEPRECATED"><code>deprecated</code></a>
</p></dd>
<dt id="flag--linkopt"><code><a href="#flag--linkopt">--linkopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to gcc when linking.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ltobackendopt"><code><a href="#flag--ltobackendopt">--ltobackendopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to the LTO backend step (under --features=thin_lto).</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ltoindexopt"><code><a href="#flag--ltoindexopt">--ltoindexopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to the LTO indexing step (under --features=thin_lto).</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--macos_cpus"><code><a href="#flag--macos_cpus">--macos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple macOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--macos_minimum_os"><code><a href="#flag--macos_minimum_os">--macos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible macOS version for targets. If unspecified, uses 'macos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--memprof_profile"><code><a href="#flag--memprof_profile">--memprof_profile</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use memprof profile.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--objc_debug_with_GLIBCXX"><code><a href="#flag--objc_debug_with_GLIBCXX">--[no]objc_debug_with_GLIBCXX</a></code> default: "false"</dt>
<dd>
<p>If set, and compilation mode is set to 'dbg', define GLIBCXX_DEBUG,  GLIBCXX_DEBUG_PEDANTIC and GLIBCPP_CONCEPT_CHECKS.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--objc_enable_binary_stripping"><code><a href="#flag--objc_enable_binary_stripping">--[no]objc_enable_binary_stripping</a></code> default: "false"</dt>
<dd>
<p>Whether to perform symbol and dead-code strippings on linked binaries. Binary strippings will be performed if both this flag and --compilation_mode=opt are specified.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--objccopt"><code><a href="#flag--objccopt">--objccopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to gcc when compiling Objective-C/C++ source files.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--per_file_copt"><code><a href="#flag--per_file_copt">--per_file_copt</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths followed by an @ and a comma separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to selectively pass to gcc when compiling certain files. This option can be passed multiple times. Syntax: regex_filter@option_1,option_2,...,option_n. Where regex_filter stands for a list of include and exclude regular expression patterns (Also see --instrumentation_filter). option_1 to option_n stand for arbitrary command line options. If an option contains a comma it has to be quoted with a backslash. Options can contain @. Only the first @ is used to split the string. Example: --per_file_copt=//foo/.*.cc,-//foo/bar.cc@-O0 adds the -O0 command line option to the gcc command line of all cc files in //foo/ except bar.cc.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--per_file_ltobackendopt"><code><a href="#flag--per_file_ltobackendopt">--per_file_ltobackendopt</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths followed by an @ and a comma separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to selectively pass to LTO backend (under --features=thin_lto) when compiling certain backend objects. This option can be passed multiple times. Syntax: regex_filter@option_1,option_2,...,option_n. Where regex_filter stands for a list of include and exclude regular expression patterns. option_1 to option_n stand for arbitrary command line options. If an option contains a comma it has to be quoted with a backslash. Options can contain @. Only the first @ is used to split the string. Example: --per_file_ltobackendopt=//foo/.*.o,-//foo/bar.o@-O0 adds the -O0 command line option to the LTO backend command line of all o files in //foo/ except bar.o.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--platform_suffix"><code><a href="#flag--platform_suffix">--platform_suffix</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specifies a suffix to be added to the configuration directory.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--propeller_optimize"><code><a href="#flag--propeller_optimize">--propeller_optimize</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use Propeller profile information to optimize the build target.A propeller profile must consist of at least one of two files, a cc profile and a ld profile.  This flag accepts a build label which must refer to the propeller profile input files. For example, the BUILD file that defines the label, in a/b/BUILD:propeller_optimize(    name = &quot;propeller_profile&quot;,    cc_profile = &quot;propeller_cc_profile.txt&quot;,    ld_profile = &quot;propeller_ld_profile.txt&quot;,)An exports_files directive may have to be added to the corresponding package to make these files visible to Bazel. The option must be used as: --propeller_optimize=//a/b:propeller_profile</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--propeller_optimize_absolute_cc_profile"><code><a href="#flag--propeller_optimize_absolute_cc_profile">--propeller_optimize_absolute_cc_profile</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Absolute path name of cc_profile file for Propeller Optimized builds.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--propeller_optimize_absolute_ld_profile"><code><a href="#flag--propeller_optimize_absolute_ld_profile">--propeller_optimize_absolute_ld_profile</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Absolute path name of ld_profile file for Propeller Optimized builds.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--run_under"><code><a href="#flag--run_under">--run_under</a>=&lt;a prefix in front of command&gt;</code> default: see description</dt>
<dd>
<p>Prefix to insert before the executables for the <code>test</code> and <code>run</code> commands.
If the value is <code>foo -bar</code>, and the execution command line is <code>test_binary -baz</code>,
then the final command line is <code>foo -bar test_binary -baz</code>.
This can also be a label to an executable target. Some examples are:</p>
<ul>
<li><code>valgrind</code></li>
<li><code>strace</code></li>
<li><code>strace -c</code></li>
<li><code>valgrind --quiet --num-callers=20</code></li>
<li><code>//package:target</code></li>
<li><code>//package:target --options</code></li>
</ul>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--share_native_deps"><code><a href="#flag--share_native_deps">--[no]share_native_deps</a></code> default: "true"</dt>
<dd>
<p>If true, native libraries that contain identical functionality will be shared among different targets</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--stamp"><code><a href="#flag--stamp">--[no]stamp</a></code> default: "false"</dt>
<dd>
<p>Stamp binaries with the date, username, hostname, workspace information, etc.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--strip"><code><a href="#flag--strip">--strip</a>=&lt;always, sometimes or never&gt;</code> default: "sometimes"</dt>
<dd>
<p>Specifies whether to strip binaries and shared libraries  (using &quot;-Wl,--strip-debug&quot;).  The default value of 'sometimes' means strip iff --compilation_mode=fastbuild.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--stripopt"><code><a href="#flag--stripopt">--stripopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to strip when generating a '&lt;name&gt;.stripped' binary.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--tvos_cpus"><code><a href="#flag--tvos_cpus">--tvos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple tvOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--tvos_minimum_os"><code><a href="#flag--tvos_minimum_os">--tvos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible tvOS version for target simulators and devices. If unspecified, uses 'tvos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--visionos_cpus"><code><a href="#flag--visionos_cpus">--visionos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple visionOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--watchos_cpus"><code><a href="#flag--watchos_cpus">--watchos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple watchOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--watchos_minimum_os"><code><a href="#flag--watchos_minimum_os">--watchos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible watchOS version for target simulators and devices. If unspecified, uses 'watchos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--xbinary_fdo"><code><a href="#flag--xbinary_fdo">--xbinary_fdo</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use XbinaryFDO profile information to optimize compilation. Specify the name of default cross binary profile. When the option is used together with --fdo_instrument/--fdo_optimize/--fdo_profile, those options will always prevail as if xbinary_fdo is never specified.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
</dl>
<dl>Options that affect how strictly Bazel enforces valid build inputs (rule definitions,  flag combinations, etc.):
<dt id="flag--check_visibility"><code><a href="#flag--check_visibility">--[no]check_visibility</a></code> default: "true"</dt>
<dd>
<p>If disabled, visibility errors in target dependencies are demoted to warnings.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--desugar_for_android"><code><a href="#flag--desugar_for_android">--[no]desugar_for_android</a></code> default: "true"</dt>
<dd>
<p>Whether to desugar Java 8 bytecode before dexing.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--desugar_java8_libs"><code><a href="#flag--desugar_java8_libs">--[no]desugar_java8_libs</a></code> default: "false"</dt>
<dd>
<p>Whether to include supported Java 8 libraries in apps for legacy devices.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--enforce_constraints"><code><a href="#flag--enforce_constraints">--[no]enforce_constraints</a></code> default: "true"</dt>
<dd>
<p>Checks the environments each target is compatible with and reports errors if any target has dependencies that don't support the same environments</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="flag--experimental_check_desugar_deps"><code><a href="#flag--experimental_check_desugar_deps">--[no]experimental_check_desugar_deps</a></code> default: "true"</dt>
<dd>
<p>Whether to double-check correct desugaring at Android binary level.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_enforce_transitive_visibility"><code><a href="#flag--experimental_enforce_transitive_visibility">--[no]experimental_enforce_transitive_visibility</a></code> default: "false"</dt>
<dd>
<p>If true, enable package()s to set the transitive_visibility attribute to restrict which packages may depend on them.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_one_version_enforcement"><code><a href="#flag--experimental_one_version_enforcement">--experimental_one_version_enforcement</a>=&lt;off, warning or error&gt;</code> default: "OFF"</dt>
<dd>
<p>When enabled, enforce that a java_binary rule can't contain more than one version of the same class file on the classpath. This enforcement can break the build, or can just result in warnings.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--experimental_strict_java_deps"><code><a href="#flag--experimental_strict_java_deps">--experimental_strict_java_deps</a>=&lt;off, warn, error, strict or default&gt;</code> default: "default"</dt>
<dd>
<p>If true, checks that a Java target explicitly declares all directly used targets as dependencies.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="flag--incompatible_check_testonly_for_output_files"><code><a href="#flag--incompatible_check_testonly_for_output_files">--[no]incompatible_check_testonly_for_output_files</a></code> default: "false"</dt>
<dd>
<p>If enabled, check testonly for prerequisite targets that are output files by looking up the testonly of the generating rule. This matches visibility checking.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_disable_native_android_rules"><code><a href="#flag--incompatible_disable_native_android_rules">--[no]incompatible_disable_native_android_rules</a></code> default: "false"</dt>
<dd>
<p>If enabled, direct usage of the native Android rules is disabled. Please use the Starlark Android rules from https://github.com/bazelbuild/rules_android</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_disable_native_apple_binary_rule"><code><a href="#flag--incompatible_disable_native_apple_binary_rule">--[no]incompatible_disable_native_apple_binary_rule</a></code> default: "false"</dt>
<dd>
<p>No-op. Kept here for backwards compatibility.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--one_version_enforcement_on_java_tests"><code><a href="#flag--one_version_enforcement_on_java_tests">--[no]one_version_enforcement_on_java_tests</a></code> default: "true"</dt>
<dd>
<p>When enabled, and with experimental_one_version_enforcement set to a non-NONE value, enforce one version on java_test targets. This flag can be disabled to improve incremental test performance at the expense of missing potential one version violations.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--python_native_rules_allowlist"><code><a href="#flag--python_native_rules_allowlist">--python_native_rules_allowlist</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>An allowlist (package_group target) to use when enforcing --incompatible_python_disallow_native_rules.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--strict_filesets"><code><a href="#flag--strict_filesets">--[no]strict_filesets</a></code> default: "false"</dt>
<dd>
<p>If this option is enabled, filesets crossing package boundaries are reported as errors.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="flag--strict_proto_deps"><code><a href="#flag--strict_proto_deps">--strict_proto_deps</a>=&lt;off, warn, error, strict or default&gt;</code> default: "error"</dt>
<dd>
<p>Unless OFF, checks that a proto_library target explicitly declares all directly used targets as dependencies.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--strict_public_imports"><code><a href="#flag--strict_public_imports">--strict_public_imports</a>=&lt;off, warn, error, strict or default&gt;</code> default: "off"</dt>
<dd>
<p>Unless OFF, checks that a proto_library target explicitly declares all targets used in 'import public' as exported.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--strict_system_includes"><code><a href="#flag--strict_system_includes">--[no]strict_system_includes</a></code> default: "false"</dt>
<dd>
<p>If true, headers found through system include paths (-isystem) are also required to be declared.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="flag--target_environment"><code><a href="#flag--target_environment">--target_environment</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Declares this build's target environment. Must be a label reference to an
<a href="https://github.com/bazelbuild/bazel/blob/master/src/main/java/com/google/devtools/build/lib/analysis/constraints/EnvironmentRule.java"><code>environment</code> rule</a>. If specified, all top-level targets must be compatible with this
environment.</p>
<p>See also <code>--platforms</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
</dl>
<dl>Options that affect the signing outputs of a build:
<dt id="flag--apk_signing_method"><code><a href="#flag--apk_signing_method">--apk_signing_method</a>=&lt;v1, v2, v1_v2 or v4&gt;</code> default: "v1_v2"</dt>
<dd>
<p>Implementation to use to sign APKs</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--device_debug_entitlements"><code><a href="#flag--device_debug_entitlements">--[no]device_debug_entitlements</a></code> default: "true"</dt>
<dd>
<p>If set, and compilation mode is not 'opt', objc apps will include debug entitlements when signing.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="flag--ios_signing_cert_name"><code><a href="#flag--ios_signing_cert_name">--ios_signing_cert_name</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Certificate name to use for iOS signing. If not set will fall back to provisioning profile. May be the certificate's keychain identity preference or (substring) of the certificate's common name, as per codesign's man page (SIGNING IDENTITIES).</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
</dl>
<dl>This option affects semantics of the Starlark language or the build API accessible to BUILD files, .bzl files, or WORKSPACE files.:
<dt id="flag--incompatible_disallow_sdk_frameworks_attributes"><code><a href="#flag--incompatible_disallow_sdk_frameworks_attributes">--[no]incompatible_disallow_sdk_frameworks_attributes</a></code> default: "false"</dt>
<dd>
<p>If true, disallow sdk_frameworks and weak_sdk_frameworks attributes in objc_library andobjc_import.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_objc_alwayslink_by_default"><code><a href="#flag--incompatible_objc_alwayslink_by_default">--[no]incompatible_objc_alwayslink_by_default</a></code> default: "false"</dt>
<dd>
<p>If true, make the default value true for alwayslink attributes in objc_library and objc_import.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_python_disallow_native_rules"><code><a href="#flag--incompatible_python_disallow_native_rules">--[no]incompatible_python_disallow_native_rules</a></code> default: "false"</dt>
<dd>
<p>When true, an error occurs when using the builtin py_* rules; instead the rule_python rules should be used. See https://github.com/bazelbuild/bazel/issues/17773 for more information and migration instructions.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options that govern the behavior of the test environment or test runner:
<dt id="flag--allow_analysis_failures"><code><a href="#flag--allow_analysis_failures">--[no]allow_analysis_failures</a></code> default: "false"</dt>
<dd>
<p>If true, an analysis failure of a rule target results in the target's propagation
of an instance of <code>AnalysisFailureInfo</code> containing the error description, instead
of resulting in a build failure.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--analysis_testing_deps_limit"><code><a href="#flag--analysis_testing_deps_limit">--analysis_testing_deps_limit</a>=&lt;an integer&gt;</code> default: "2000"</dt>
<dd>
<p>Sets the maximum number of transitive dependencies through a rule attribute with
a <code>for_analysis_testing</code> configuration transition.
Exceeding this limit will result in a rule error.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--break_build_on_parallel_dex2oat_failure"><code><a href="#flag--break_build_on_parallel_dex2oat_failure">--[no]break_build_on_parallel_dex2oat_failure</a></code> default: "false"</dt>
<dd>
<p>If true dex2oat action failures will cause the build to break instead of executing dex2oat during test runtime.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--default_test_resources"><code><a href="#flag--default_test_resources">--default_test_resources</a>=&lt;a resource name followed by equal and 1 float or 4 float, e.g memory=10,30,60,100&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Override the default resources amount for tests. The expected format is
<code>{resource}={value}</code>. If a single positive number is specified as <code>{value}</code>
it will override the default resources for all test sizes. If 4
comma-separated numbers are specified, they will override the resource
amount for respectively the <code>small</code>, <code>medium</code>, <code>large</code>, <code>enormous</code> test sizes.
Values can also be <code>HOST_RAM</code>/<code>HOST_CPU</code>, optionally followed
by <code>[-|*]{float}</code> (eg. <code>memory=HOST_RAM*.1,HOST_RAM*.2,HOST_RAM*.3,HOST_RAM*.4</code>).
The default test resources specified by this flag are overridden by explicit
resources specified in tags.</p>
</dd>
<dt id="flag--experimental_android_use_parallel_dex2oat"><code><a href="#flag--experimental_android_use_parallel_dex2oat">--[no]experimental_android_use_parallel_dex2oat</a></code> default: "false"</dt>
<dd>
<p>Use dex2oat in parallel to possibly speed up android_test.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--ios_memleaks"><code><a href="#flag--ios_memleaks">--[no]ios_memleaks</a></code> default: "false"</dt>
<dd>
<p>Enable checking for memory leaks in ios_test targets.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--ios_simulator_device"><code><a href="#flag--ios_simulator_device">--ios_simulator_device</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The device to simulate when running an iOS application in the simulator, e.g. 'iPhone 6'. You can get a list of devices by running 'xcrun simctl list devicetypes' on the machine the simulator will be run on.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
<dt id="flag--ios_simulator_version"><code><a href="#flag--ios_simulator_version">--ios_simulator_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>The version of iOS to run on the simulator when running or testing. This is ignored for ios_test rules if a target device is specified in the rule.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
<dt id="flag--runs_per_test"><code><a href="#flag--runs_per_test">--runs_per_test</a>=&lt;a positive integer or test_regex@runs. This flag may be passed more than once&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies number of times to run each test. If any of those attempts fail for any
reason, the whole test is considered failed. Normally the value specified is
just an integer.</p>
<p>Example: <code>--runs_per_test=3</code> will run all tests 3 times.</p>
<p>Alternate syntax: <code>regex_filter@runs_per_test</code>. Where <code>runs_per_test</code> stands for
an integer value and <code>regex_filter</code> stands for a list of include and exclude
regular expression patterns (Also see --instrumentation_filter).</p>
<p>Example: <code>--runs_per_test=//foo/.*,-//foo/bar/.*@3</code> runs all tests in <code>//foo/</code> except
those under <code>//foo/bar</code> three times. This option can be passed multiple times. The most
recently passed argument that matches takes precedence. If nothing matches,
the test is only run once.</p>
</dd>
<dt id="flag--test_env"><code><a href="#flag--test_env">--test_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies additional environment variables to be injected into the test runner
environment. Variables can be either specified by <code>name</code>, in which
case its value will be read from the Bazel client environment, or by the
<code>name=value</code> pair.
Previously set variables can be unset via <code>=name</code>.
This option can be used multiple times to specify several variables.
Used only by the 'bazel test' command.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
<dt id="flag--test_timeout"><code><a href="#flag--test_timeout">--test_timeout</a>=&lt;a single integer or comma-separated list of 4 integers&gt;</code> default: "-1"</dt>
<dd>
<p>Override the default test timeout values for test timeouts (in secs). If a single
positive integer value is specified it will override all categories.  If 4
comma-separated integers are specified, they will override the timeouts for
<code>short</code>, <code>moderate</code>, <code>long</code> and <code>eternal</code> (in that order). In either form, a value of
-1 tells blaze to use its default timeouts for that category.</p>
</dd>
<dt id="flag--zip_undeclared_test_outputs"><code><a href="#flag--zip_undeclared_test_outputs">--[no]zip_undeclared_test_outputs</a></code> default: "false"</dt>
<dd>
<p>If true, undeclared test outputs will be archived in a zip file.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
</dl>
<dl>Options that trigger optimizations of the build time:
<dt id="flag--cc_dotd_files"><code><a href="#flag--cc_dotd_files">--[no]cc_dotd_files</a></code> default: "true"</dt>
<dd>
<p>Whether to generate and analyze .d files.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="flag--cc_include_scanning"><code><a href="#flag--cc_include_scanning">--[no]cc_include_scanning</a></code> default: "false"</dt>
<dd>
<p>Whether to narrow inputs to C/C++ compilation by parsing #include lines from input files. This can improve performance and incrementality by decreasing the size of compilation input trees. However, it can also break builds because the include scanner does not fully implement C preprocessor semantics. In particular, it does not understand dynamic #include directives and ignores preprocessor conditional logic. Use at your own risk. Any issues relating to this flag that are filed will be closed. At Google without this flag your build will most likely fail.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_filter_library_jar_with_program_jar"><code><a href="#flag--experimental_filter_library_jar_with_program_jar">--[no]experimental_filter_library_jar_with_program_jar</a></code> default: "false"</dt>
<dd>
<p>Filter the ProGuard ProgramJar to remove any classes also present in the LibraryJar.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_inmemory_dotd_files"><code><a href="#flag--experimental_inmemory_dotd_files">--[no]experimental_inmemory_dotd_files</a></code> default: "true"</dt>
<dd>
<p>If enabled, C++ .d files will be passed through in memory directly from the remote build nodes instead of being written to disk.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_inmemory_jdeps_files"><code><a href="#flag--experimental_inmemory_jdeps_files">--[no]experimental_inmemory_jdeps_files</a></code> default: "true"</dt>
<dd>
<p>If enabled, the dependency (.jdeps) files generated from Java compilations will be passed through in memory directly from the remote build nodes instead of being written to disk.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_retain_test_configuration_across_testonly"><code><a href="#flag--experimental_retain_test_configuration_across_testonly">--[no]experimental_retain_test_configuration_across_testonly</a></code> default: "false"</dt>
<dd>
<p>When enabled, <code>--trim_test_configuration</code> will not trim the test configuration for rules
marked testonly=1. This is meant to reduce action conflict issues when non-test
rules depend on <code>cc_test</code> rules. No effect if <code>--trim_test_configuration</code> is
false.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_unsupported_and_brittle_include_scanning"><code><a href="#flag--experimental_unsupported_and_brittle_include_scanning">--[no]experimental_unsupported_and_brittle_include_scanning</a></code> default: "false"</dt>
<dd>
<p>Whether to narrow inputs to C/C++ compilation by parsing #include lines from input files. This can improve performance and incrementality by decreasing the size of compilation input trees. However, it can also break builds because the include scanner does not fully implement C preprocessor semantics. In particular, it does not understand dynamic #include directives and ignores preprocessor conditional logic. Use at your own risk. Any issues relating to this flag that are filed will be closed. At Google without this flag your build will most likely fail.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--incremental_dexing"><code><a href="#flag--incremental_dexing">--[no]incremental_dexing</a></code> default: "true"</dt>
<dd>
<p>Does most of the work for dexing separately for each Jar file.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--objc_use_dotd_pruning"><code><a href="#flag--objc_use_dotd_pruning">--[no]objc_use_dotd_pruning</a></code> default: "true"</dt>
<dd>
<p>If set, .d files emitted by clang will be used to prune the set of inputs passed into objc compiles.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--process_headers_in_dependencies"><code><a href="#flag--process_headers_in_dependencies">--[no]process_headers_in_dependencies</a></code> default: "false"</dt>
<dd>
<p>When building a target //a:a, process headers in all targets that //a:a depends on (if header processing is enabled for the toolchain).</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--trim_test_configuration"><code><a href="#flag--trim_test_configuration">--[no]trim_test_configuration</a></code> default: "true"</dt>
<dd>
<p>When enabled, test-related options will be cleared below the top level of the build. When this flag is active, tests cannot be built as dependencies of non-test rules, but changes to test-related options will not cause non-test rules to be re-analyzed.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
</dl>
<dl>Options that affect the verbosity, format or location of logging:
<dt id="flag--toolchain_resolution_debug"><code><a href="#flag--toolchain_resolution_debug">--toolchain_resolution_debug</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths&gt;</code> default: "-.*"</dt>
<dd>
<p>Print debug information during toolchain resolution. The flag takes a regex, which is checked against toolchain types and specific targets to see which to debug. Multiple regexes may be  separated by commas, and then each regex is checked separately. Note: The output of this flag is very complex and will likely only be useful to experts in toolchain resolution.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="flag--verbose_visibility_errors"><code><a href="#flag--verbose_visibility_errors">--[no]verbose_visibility_errors</a></code> default: "false"</dt>
<dd>
<p>If enabled, visibility errors include additional diagnostic information.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
</dl>
<dl>Options specifying or altering a generic input to a Bazel command that does not fall into other categories.:
<dt id="flag--flag_alias"><code><a href="#flag--flag_alias">--flag_alias</a>=&lt;a &#39;name=value&#39; flag alias&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Sets a shorthand name for a Starlark flag. It takes a single key-value pair in the form
<code>{key}={value}</code> as an argument.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--incompatible_default_to_explicit_init_py"><code><a href="#flag--incompatible_default_to_explicit_init_py">--[no]incompatible_default_to_explicit_init_py</a></code> default: "false"</dt>
<dd>
<p>This flag changes the default behavior so that <strong>init</strong>.py files are no longer automatically created in the runfiles of Python targets. Precisely, when a py_binary or py_test target has legacy_create_init set to &quot;auto&quot; (the default), it is treated as false if and only if this flag is set. See https://github.com/bazelbuild/bazel/issues/10076.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Miscellaneous options, not otherwise categorized.:
<dt id="flag--cache_test_results"><code><a href="#flag--cache_test_results">--[no]cache_test_results</a></code> [<code>-t</code>] default: "auto"</dt>
<dd>
<p>If set to <code>auto</code>, Bazel reruns a test if and only if:</p>
<ol>
<li>Bazel detects changes in the test or its dependencies,</li>
<li>The test is marked as <code>external</code>,</li>
<li>Multiple test runs were requested with <code>--runs_per_test</code>, or</li>
<li>The test previously failed.
If set to <code>yes</code>, Bazel caches all test results except for tests marked as
<code>external</code>. If set to <code>no</code>, Bazel does not cache any test results.</li>
</ol>
</dd>
<dt id="flag--experimental_cancel_concurrent_tests"><code><a href="#flag--experimental_cancel_concurrent_tests">--[no]experimental_cancel_concurrent_tests</a></code> default: "never"</dt>
<dd>
<p>If <code>on_failed</code> or <code>on_passed</code>, then Blaze will cancel concurrently running tests on the first
successful run with that result. This is only useful in combination with
<code>--runs_per_test_detects_flakes</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_fetch_all_coverage_outputs"><code><a href="#flag--experimental_fetch_all_coverage_outputs">--[no]experimental_fetch_all_coverage_outputs</a></code> default: "false"</dt>
<dd>
<p>If true, then Bazel fetches the entire coverage data directory for each test during a coverage run.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_generate_llvm_lcov"><code><a href="#flag--experimental_generate_llvm_lcov">--[no]experimental_generate_llvm_lcov</a></code> default: "false"</dt>
<dd>
<p>If true, coverage for clang will generate an LCOV report.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_java_classpath"><code><a href="#flag--experimental_java_classpath">--experimental_java_classpath</a>=&lt;off, javabuilder, bazel or bazel_no_fallback&gt;</code> default: "bazel"</dt>
<dd>
<p>Enables reduced classpaths for Java compilations.</p>
</dd>
<dt id="flag--experimental_run_android_lint_on_java_rules"><code><a href="#flag--experimental_run_android_lint_on_java_rules">--[no]experimental_run_android_lint_on_java_rules</a></code> default: "false"</dt>
<dd>
<p>Whether to validate java_* sources.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--explicit_java_test_deps"><code><a href="#flag--explicit_java_test_deps">--[no]explicit_java_test_deps</a></code> default: "false"</dt>
<dd>
<p>Explicitly specify a dependency to JUnit or Hamcrest in a java_test instead of  accidentally obtaining from the TestRunner's deps. Only works for bazel right now.</p>
</dd>
<dt id="flag--host_java_launcher"><code><a href="#flag--host_java_launcher">--host_java_launcher</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The Java launcher used by tools that are executed during a build.</p>
</dd>
<dt id="flag--host_javacopt"><code><a href="#flag--host_javacopt">--host_javacopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to javac when building tools that are executed during a build.</p>
</dd>
<dt id="flag--host_jvmopt"><code><a href="#flag--host_jvmopt">--host_jvmopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the Java VM when building tools that are executed during  the build. These options will get added to the VM startup options of each  java_binary target.</p>
</dd>
<dt id="flag--incompatible_check_sharding_support"><code><a href="#flag--incompatible_check_sharding_support">--[no]incompatible_check_sharding_support</a></code> default: "true"</dt>
<dd>
<p>If true, Bazel will fail a sharded test if the test runner does not indicate that it
supports sharding by touching the file at the path in <code>TEST_SHARD_STATUS_FILE</code>.
If false, a test runner that does not support sharding will lead to all tests
running in each shard.</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_exclusive_test_sandboxed"><code><a href="#flag--incompatible_exclusive_test_sandboxed">--[no]incompatible_exclusive_test_sandboxed</a></code> default: "true"</dt>
<dd>
<p>If true, exclusive tests will run with sandboxed strategy. Add <code>local</code> tag to force
an exclusive test run locally</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_strict_action_env"><code><a href="#flag--incompatible_strict_action_env">--[no]incompatible_strict_action_env</a></code> default: "false"</dt>
<dd>
<p>If true, Bazel uses an environment with a static value for PATH and does not
inherit <code>LD_LIBRARY_PATH</code>. Use <code>--action_env=ENV_VARIABLE</code> if you want to
inherit specific environment variables from the client, but note that doing so
can prevent cross-user caching if a shared cache is used.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--j2objc_translation_flags"><code><a href="#flag--j2objc_translation_flags">--j2objc_translation_flags</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the J2ObjC tool.</p>
</dd>
<dt id="flag--java_debug"><code><a href="#flag--java_debug">--java_debug</a></code></dt>
<dd>
<p>Causes the Java virtual machine of a java test to wait for a connection from a JDWP-compliant debugger (such as jdb) before starting the test. Implies -test_output=streamed.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--test_arg">--test_arg=--wrapper_script_flag=--debug</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--test_output">--test_output=streamed</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--test_strategy">--test_strategy=exclusive</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--test_timeout">--test_timeout=9999</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--nocache_test_results">--nocache_test_results</a></code>
</p></dd>
<dt id="flag--java_deps"><code><a href="#flag--java_deps">--[no]java_deps</a></code> default: "true"</dt>
<dd>
<p>Generate dependency information (for now, compile-time classpath) per Java target.</p>
</dd>
<dt id="flag--java_header_compilation"><code><a href="#flag--java_header_compilation">--[no]java_header_compilation</a></code> default: "true"</dt>
<dd>
<p>Compile ijars directly from source.</p>
</dd>
<dt id="flag--java_language_version"><code><a href="#flag--java_language_version">--java_language_version</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The Java language version</p>
</dd>
<dt id="flag--java_launcher"><code><a href="#flag--java_launcher">--java_launcher</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The Java launcher to use when building Java binaries.  If this flag is set to the empty string, the JDK launcher is used. The &quot;launcher&quot; attribute overrides this flag.</p>
</dd>
<dt id="flag--java_runtime_version"><code><a href="#flag--java_runtime_version">--java_runtime_version</a>=&lt;a string&gt;</code> default: "local_jdk"</dt>
<dd>
<p>The Java runtime version</p>
</dd>
<dt id="flag--javacopt"><code><a href="#flag--javacopt">--javacopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to javac.</p>
</dd>
<dt id="flag--jvmopt"><code><a href="#flag--jvmopt">--jvmopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the Java VM. These options will get added to the VM startup options of each java_binary target.</p>
</dd>
<dt id="flag--legacy_main_dex_list_generator"><code><a href="#flag--legacy_main_dex_list_generator">--legacy_main_dex_list_generator</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies a binary to use to generate the list of classes that must be in the main dex when compiling legacy multidex.</p>
</dd>
<dt id="flag--optimizing_dexer"><code><a href="#flag--optimizing_dexer">--optimizing_dexer</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies a binary to use to do dexing without sharding.</p>
</dd>
<dt id="flag--plugin"><code><a href="#flag--plugin">--plugin</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Plugins to use in the build. Currently works with java_plugin.</p>
</dd>
<dt id="flag--proguard_top"><code><a href="#flag--proguard_top">--proguard_top</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies which version of ProGuard to use for code removal when building a Java binary.</p>
</dd>
<dt id="flag--proto_compiler"><code><a href="#flag--proto_compiler">--proto_compiler</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:protoc"</dt>
<dd>
<p>The label of the proto-compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_profile"><code><a href="#flag--proto_profile">--[no]proto_profile</a></code> default: "true"</dt>
<dd>
<p>Whether to pass profile_path to the proto compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_profile_path"><code><a href="#flag--proto_profile_path">--proto_profile_path</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The profile to pass to the proto compiler as profile_path. If unset, but  --proto_profile is true (the default), infers the path from --fdo_optimize.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_cc"><code><a href="#flag--proto_toolchain_for_cc">--proto_toolchain_for_cc</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:cc_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile C++ protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_j2objc"><code><a href="#flag--proto_toolchain_for_j2objc">--proto_toolchain_for_j2objc</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/j2objc:j2objc_proto_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile j2objc protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_java"><code><a href="#flag--proto_toolchain_for_java">--proto_toolchain_for_java</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:java_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile Java protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_javalite"><code><a href="#flag--proto_toolchain_for_javalite">--proto_toolchain_for_javalite</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:javalite_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile JavaLite protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--protocopt"><code><a href="#flag--protocopt">--protocopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the protobuf compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--runs_per_test_detects_flakes"><code><a href="#flag--runs_per_test_detects_flakes">--[no]runs_per_test_detects_flakes</a></code> default: "false"</dt>
<dd>
<p>If true, any shard in which at least one run/attempt passes and at least one run/attempt fails gets a FLAKY status.</p>
</dd>
<dt id="flag--shell_executable"><code><a href="#flag--shell_executable">--shell_executable</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>Absolute path to the shell executable for Bazel to use. If this is unset, but the
<code>BAZEL_SH</code> environment variable is set on the first Bazel invocation (that starts
up a Bazel server), Bazel uses that. If neither is set, Bazel uses a hard-coded
default path depending on the operating system it runs on;</p>
<ul>
<li>Windows: <code>c:/msys64/usr/bin/bash.exe</code></li>
<li>FreeBSD: <code>/usr/local/bin/bash</code></li>
<li>All others: <code>/bin/bash</code>.</li>
</ul>
<p>Note that using a shell that is not compatible with <code>bash</code> may lead
to build failures or runtime failures of the generated binaries.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--test_arg"><code><a href="#flag--test_arg">--test_arg</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies additional options and arguments that should be passed to the test
executable. Can be used multiple times to specify several arguments.
If multiple tests are executed, each of them will receive identical arguments.
Used only by the <code>bazel test</code> command.</p>
</dd>
<dt id="flag--test_filter"><code><a href="#flag--test_filter">--test_filter</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specifies a filter to forward to the test framework.  Used to limit the tests run. Note that this does not affect which targets are built.</p>
</dd>
<dt id="flag--test_result_expiration"><code><a href="#flag--test_result_expiration">--test_result_expiration</a>=&lt;an integer&gt;</code> default: "-1"</dt>
<dd>
<p>This option is deprecated and has no effect.</p>
</dd>
<dt id="flag--test_runner_fail_fast"><code><a href="#flag--test_runner_fail_fast">--[no]test_runner_fail_fast</a></code> default: "false"</dt>
<dd>
<p>Forwards fail fast option to the test runner. The test runner should stop execution upon first failure.</p>
</dd>
<dt id="flag--test_sharding_strategy"><code><a href="#flag--test_sharding_strategy">--test_sharding_strategy</a>=&lt;explicit, disabled or forced=k where k is the number of shards to enforce&gt;</code> default: "explicit"</dt>
<dd>
<p>Specify strategy for test sharding:</p>
<ul>
<li><code>explicit</code> to only use sharding if the <code>shard_count</code> <code>BUILD</code> attribute is
present.</li>
<li><code>disabled</code> to never use test sharding.</li>
<li><code>forced=k</code> to enforce <code>k</code> shards for testing regardless of the <code>shard_count</code> <code>BUILD</code>
attribute.</li>
</ul>
</dd>
<dt id="flag--tool_java_language_version"><code><a href="#flag--tool_java_language_version">--tool_java_language_version</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The Java language version used to execute the tools that are needed during a build</p>
</dd>
<dt id="flag--tool_java_runtime_version"><code><a href="#flag--tool_java_runtime_version">--tool_java_runtime_version</a>=&lt;a string&gt;</code> default: "remotejdk_11"</dt>
<dd>
<p>The Java runtime version used to execute tools during the build</p>
</dd>
<dt id="flag--use_ijars"><code><a href="#flag--use_ijars">--[no]use_ijars</a></code> default: "true"</dt>
<dd>
<p>If enabled, this option causes Java compilation to use interface jars. This will result in faster incremental compilation, but error messages can be different.</p>
</dd>
</dl>

<h2><a name="dump">Dump Options</a></h2>
<dl>Options that control the output of the command:
<dt id="dump-flag--action_cache"><code id="action_cache"><a href="#dump-flag--action_cache">--[no]action_cache</a></code> default: "false"</dt>
<dd>
<p>Dump action cache content.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="dump-flag--memory"><code id="memory"><a href="#dump-flag--memory">--memory</a>=&lt;memory mode&gt;</code> default: see description</dt>
<dd>
<p>Dump the memory use of the given Skyframe node.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="dump-flag--packages"><code id="packages"><a href="#dump-flag--packages">--[no]packages</a></code> default: "false"</dt>
<dd>
<p>Dump package cache content.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="dump-flag--rule_classes"><code id="rule_classes"><a href="#dump-flag--rule_classes">--[no]rule_classes</a></code> default: "false"</dt>
<dd>
<p>Dump rule classes.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="dump-flag--rules"><code id="rules"><a href="#dump-flag--rules">--[no]rules</a></code> default: "false"</dt>
<dd>
<p>Dump rules, including counts and memory usage (if memory is tracked).</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="dump-flag--skyframe"><code id="skyframe"><a href="#dump-flag--skyframe">--skyframe</a>=&lt;off, summary, count, value, deps, rdeps, function_graph, active_directories or active_directories_frontier_deps&gt;</code> default: "off"</dt>
<dd>
<p>Dump the Skyframe graph.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="dump-flag--skykey_filter"><code id="skykey_filter"><a href="#dump-flag--skykey_filter">--skykey_filter</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths&gt;</code> default: ".*"</dt>
<dd>
<p>Regex filter of SkyKey names to output. Only used with --skyframe=deps, rdeps, function_graph.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
<dt id="dump-flag--skylark_memory"><code id="skylark_memory"><a href="#dump-flag--skylark_memory">--skylark_memory</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Dumps a pprof-compatible memory profile to the specified path. To learn more please see https://github.com/google/pprof.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
</dl>

<h2><a name="fetch">Fetch Options</a></h2>
<p>Inherits all options from <a href="#test">test</a>.</p>

<dl>Options that control build execution:
<dt id="fetch-flag--all"><code id="all"><a href="#fetch-flag--all">--[no]all</a></code> default: "false"</dt>
<dd>
<p>Fetches all external repositories necessary for building any target or repository.
This is the default if no other flags and arguments are provided. Only works
when <code>--enable_bzlmod</code> is on.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="fetch-flag--keep_going"><code id="keep_going"><a href="#fetch-flag--keep_going">--[no]keep_going</a></code> [<code>-k</code>] default: "false"</dt>
<dd>
<p>Continue as much as possible after an error.  While the target that failed and those that depend on it cannot be analyzed, other prerequisites of these targets can be.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="fetch-flag--loading_phase_threads"><code id="loading_phase_threads"><a href="#fetch-flag--loading_phase_threads">--loading_phase_threads</a>=&lt;an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|*]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS*.5&quot;&gt;</code> default: "auto"</dt>
<dd>
<p>Number of parallel threads to use for the loading/analysis phase.Takes an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|<em>]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS</em>.5&quot;. &quot;auto&quot; sets a reasonable default based on host resources. Must be at least 1.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
</dl>
<dl>This option affects semantics of the Starlark language or the build API accessible to BUILD files, .bzl files, or WORKSPACE files.:
<dt id="fetch-flag--incompatible_config_setting_private_default_visibility"><code id="incompatible_config_setting_private_default_visibility"><a href="#fetch-flag--incompatible_config_setting_private_default_visibility">--[no]incompatible_config_setting_private_default_visibility</a></code> default: "false"</dt>
<dd>
<p>If incompatible_enforce_config_setting_visibility=false, this is a noop. Else, if this flag is false, any config_setting without an explicit visibility attribute is //visibility:public. If this flag is true, config_setting follows the same visibility logic as all other rules. See https://github.com/bazelbuild/bazel/issues/12933.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="fetch-flag--incompatible_enforce_config_setting_visibility"><code id="incompatible_enforce_config_setting_visibility"><a href="#fetch-flag--incompatible_enforce_config_setting_visibility">--[no]incompatible_enforce_config_setting_visibility</a></code> default: "true"</dt>
<dd>
<p>If true, enforce config_setting visibility restrictions. If false, every config_setting is visible to every target. See https://github.com/bazelbuild/bazel/issues/12932.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options relating to Bzlmod output and semantics:
<dt id="fetch-flag--configure"><code id="configure"><a href="#fetch-flag--configure">--[no]configure</a></code> default: "false"</dt>
<dd>
<p>Only fetches repositories marked as <code>configure</code> for system-configuration purpose. Only
works when <code>--enable_bzlmod</code> is on.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="fetch-flag--force"><code id="force"><a href="#fetch-flag--force">--[no]force</a></code> default: "false"</dt>
<dd>
<p>Ignore existing repository if any and force fetch the repository again. Only works when
<code>--enable_bzlmod</code> is on.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="fetch-flag--repo"><code id="repo"><a href="#fetch-flag--repo">--repo</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Only fetches the specified repository, which can be either <code>@apparent_repo_name</code> or
<code>@@canonical_repo_name</code>. Only works when <code>--enable_bzlmod</code> is on.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
</dl>
<dl>Miscellaneous options, not otherwise categorized.:
<dt id="fetch-flag--deleted_packages"><code id="deleted_packages"><a href="#fetch-flag--deleted_packages">--deleted_packages</a>=&lt;comma-separated list of package names&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>A comma-separated list of names of packages which the build system will consider non-existent, even if they are visible somewhere on the package path.
Use this option when deleting a subpackage 'x/y' of an existing package 'x'.  For example, after deleting x/y/BUILD in your client, the build system may complain if it encounters a label '//x:y/z' if that is still provided by another package_path entry.  Specifying --deleted_packages x/y avoids this problem.</p>
</dd>
<dt id="fetch-flag--fetch"><code id="fetch"><a href="#fetch-flag--fetch">--[no]fetch</a></code> default: "true"</dt>
<dd>
<p>Allows the command to fetch external dependencies. If set to false, the command will utilize any cached version of the dependency, and if none exists, the command will result in failure.</p>
</dd>
<dt id="fetch-flag--package_path"><code id="package_path"><a href="#fetch-flag--package_path">--package_path</a>=&lt;colon-separated list of options&gt;</code> default: "%workspace%"</dt>
<dd>
<p>A colon-separated list of where to look for packages. Elements beginning with '%workspace%' are relative to the enclosing workspace. If omitted or empty, the default is the output of 'bazel info default-package-path'.</p>
</dd>
<dt id="fetch-flag--show_loading_progress"><code id="show_loading_progress"><a href="#fetch-flag--show_loading_progress">--[no]show_loading_progress</a></code> default: "true"</dt>
<dd>
<p>If enabled, causes Bazel to print &quot;Loading package:&quot; messages.</p>
</dd>
</dl>

<dl>Options that control build execution:
<dt id="flag--experimental_persistent_aar_extractor"><code><a href="#flag--experimental_persistent_aar_extractor">--[no]experimental_persistent_aar_extractor</a></code> default: "false"</dt>
<dd>
<p>Enable persistent aar extractor by using workers.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_remotable_source_manifests"><code><a href="#flag--experimental_remotable_source_manifests">--[no]experimental_remotable_source_manifests</a></code> default: "false"</dt>
<dd>
<p>Whether to make source manifest actions remotable</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_split_coverage_postprocessing"><code><a href="#flag--experimental_split_coverage_postprocessing">--[no]experimental_split_coverage_postprocessing</a></code> default: "false"</dt>
<dd>
<p>If true, then Bazel will run coverage postprocessing for test in a new spawn.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_strict_fileset_output"><code><a href="#flag--experimental_strict_fileset_output">--[no]experimental_strict_fileset_output</a></code> default: "false"</dt>
<dd>
<p>If this option is enabled, filesets will treat all output artifacts as regular files. They will not traverse directories or be sensitive to symlinks.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--incompatible_modify_execution_info_additive"><code><a href="#flag--incompatible_modify_execution_info_additive">--[no]incompatible_modify_execution_info_additive</a></code> default: "true"</dt>
<dd>
<p>When enabled, passing multiple <code>--modify_execution_info</code> flags is additive.
When disabled, only the last flag is taken into account.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--modify_execution_info"><code><a href="#flag--modify_execution_info">--modify_execution_info</a>=&lt;regex=[+-]key,regex=[+-]key,...&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Add or remove keys from an action's execution info based on action mnemonic.
Applies only to actions which support execution info. Many common actions
support execution info, e.g. Genrule, CppCompile, Javac, StarlarkAction,
TestRunner. When specifying multiple values, order matters because
many regexes may apply to the same mnemonic.</p>
<p>Syntax: <code>regex=[+-]key,regex=[+-]key,...</code>.</p>
<p>Examples:</p>
<ul>
<li><code>.*=+x,.*=-y,.*=+z</code> adds <code>x</code> and <code>z</code> to, and removes <code>y</code> from, the execution info for all actions.</li>
<li><code>Genrule=+requires-x</code> adds <code>requires-x</code> to the execution info for all Genrule actions.</li>
<li><code>(?!Genrule).*=-requires-x</code> removes <code>requires-x</code> from the execution info for all non-Genrule actions.</li>
</ul>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--persistent_android_dex_desugar"><code><a href="#flag--persistent_android_dex_desugar">--persistent_android_dex_desugar</a></code></dt>
<dd>
<p>Enable persistent Android dex and desugar actions by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_android_dex_desugar">--internal_persistent_android_dex_desugar</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=Desugar=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=DexBuilder=worker</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_android_resource_processor"><code><a href="#flag--persistent_android_resource_processor">--persistent_android_resource_processor</a></code></dt>
<dd>
<p>Enable persistent Android resource processor by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_busybox_tools">--internal_persistent_busybox_tools</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AaptPackage=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceParser=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceValidator=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceCompiler=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=RClassGenerator=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceLink=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidAapt2=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidAssetMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidCompiledResourceMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=ManifestMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidManifestMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=Aapt2Optimize=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AARGenerator=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=ProcessDatabinding=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=GenerateDataBindingBaseClasses=worker</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_multiplex_android_dex_desugar"><code><a href="#flag--persistent_multiplex_android_dex_desugar">--persistent_multiplex_android_dex_desugar</a></code></dt>
<dd>
<p>Enable persistent multiplexed Android dex and desugar actions by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_android_dex_desugar">--persistent_android_dex_desugar</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_multiplex_android_dex_desugar">--internal_persistent_multiplex_android_dex_desugar</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_multiplex_android_resource_processor"><code><a href="#flag--persistent_multiplex_android_resource_processor">--persistent_multiplex_android_resource_processor</a></code></dt>
<dd>
<p>Enable persistent multiplexed Android resource processor by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_android_resource_processor">--persistent_android_resource_processor</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AaptPackage=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceParser=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceValidator=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceCompiler=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=RClassGenerator=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceLink=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidAapt2=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidAssetMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidCompiledResourceMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=ManifestMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidManifestMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=Aapt2Optimize=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AARGenerator=+supports-multiplex-workers</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_multiplex_android_tools"><code><a href="#flag--persistent_multiplex_android_tools">--persistent_multiplex_android_tools</a></code></dt>
<dd>
<p>Enable persistent and multiplexed Android tools (dexing, desugaring, resource processing).</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_multiplex_busybox_tools">--internal_persistent_multiplex_busybox_tools</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_multiplex_android_resource_processor">--persistent_multiplex_android_resource_processor</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_multiplex_android_dex_desugar">--persistent_multiplex_android_dex_desugar</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--use_target_platform_for_tests"><code><a href="#flag--use_target_platform_for_tests">--[no]use_target_platform_for_tests</a></code> default: "false"</dt>
<dd>
<p>If true, use the target platform for running tests rather than the test exec group.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
</dl>
<dl>Options that configure the toolchain used for action execution:
<dt id="flag--android_compiler"><code><a href="#flag--android_compiler">--android_compiler</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The Android target compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--android_manifest_merger"><code><a href="#flag--android_manifest_merger">--android_manifest_merger</a>=&lt;legacy, android or force_android&gt;</code> default: "android"</dt>
<dd>
<p>Selects the manifest merger to use for android_binary rules. Flag to help the transition to the Android manifest merger from the legacy merger.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--android_platforms"><code><a href="#flag--android_platforms">--android_platforms</a>=&lt;a build target label&gt;</code> default: ""</dt>
<dd>
<p>Sets the platforms that android_binary targets use. If multiple platforms are specified, then the binary is a fat APKs, which contains native binaries for each specified target platform.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--cc_output_directory_tag"><code><a href="#flag--cc_output_directory_tag">--cc_output_directory_tag</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Specifies a suffix to be added to the configuration directory.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--compiler"><code><a href="#flag--compiler">--compiler</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The C++ compiler to use for compiling the target.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--coverage_output_generator"><code><a href="#flag--coverage_output_generator">--coverage_output_generator</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/test:lcov_merger"</dt>
<dd>
<p>Location of the binary that is used to postprocess raw coverage reports. This must
be a binary target. Defaults to <code>@bazel_tools//tools/test:lcov_merger</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--coverage_report_generator"><code><a href="#flag--coverage_report_generator">--coverage_report_generator</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/test:coverage_report_generator"</dt>
<dd>
<p>Location of the binary that is used to generate coverage reports. This must
be a binary target. Defaults to <code>@bazel_tools//tools/test:coverage_report_generator</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--coverage_support"><code><a href="#flag--coverage_support">--coverage_support</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/test:coverage_support"</dt>
<dd>
<p>Location of support files that are required on the inputs of every test action
that collects code coverage. Defaults to <code>//tools/test:coverage_support</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--custom_malloc"><code><a href="#flag--custom_malloc">--custom_malloc</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies a custom malloc implementation. This setting overrides malloc attributes in build rules.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--experimental_include_xcode_execution_requirements"><code><a href="#flag--experimental_include_xcode_execution_requirements">--[no]experimental_include_xcode_execution_requirements</a></code> default: "false"</dt>
<dd>
<p>If set, add a &quot;requires-xcode:{version}&quot; execution requirement to every Xcode action.  If the Xcode version has a hyphenated label,  also add a &quot;requires-xcode-label:{version_label}&quot; execution requirement.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_prefer_mutual_xcode"><code><a href="#flag--experimental_prefer_mutual_xcode">--[no]experimental_prefer_mutual_xcode</a></code> default: "true"</dt>
<dd>
<p>If true, use the most recent Xcode that is available both locally and remotely. If false, or if there are no mutual available versions, use the local Xcode version selected via xcode-select.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--extra_execution_platforms"><code><a href="#flag--extra_execution_platforms">--extra_execution_platforms</a>=&lt;comma-separated list of options&gt;</code> default: ""</dt>
<dd>
<p>The platforms that are available as execution platforms to run actions.
Platforms can be specified by exact target, or as a target pattern.
These platforms will be considered before those declared in the <code>WORKSPACE</code> file by
<code>register_execution_platforms()</code>. This option may only be set once; later
instances will override earlier flag settings.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--extra_toolchains"><code><a href="#flag--extra_toolchains">--extra_toolchains</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The toolchain rules to be considered during toolchain resolution.
Toolchains can be specified by exact target, or as a target pattern.
These toolchains will be considered before those declared in the <code>WORKSPACE</code> file
by <code>register_toolchains()</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--grte_top"><code><a href="#flag--grte_top">--grte_top</a>=&lt;a label&gt;</code> default: see description</dt>
<dd>
<p>A label to a checked-in libc library. The default value is selected by the crosstool toolchain, and you almost never need to override it.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_compiler"><code><a href="#flag--host_compiler">--host_compiler</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>No-op flag. Will be removed in a future release.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--host_grte_top"><code><a href="#flag--host_grte_top">--host_grte_top</a>=&lt;a label&gt;</code> default: see description</dt>
<dd>
<p>If specified, this setting overrides the libc top-level directory (--grte_top) for the exec configuration.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_platform"><code><a href="#flag--host_platform">--host_platform</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools:host_platform"</dt>
<dd>
<p>The label of a platform rule that describes the host system.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--incompatible_bazel_test_exec_run_under"><code><a href="#flag--incompatible_bazel_test_exec_run_under">--[no]incompatible_bazel_test_exec_run_under</a></code> default: "true"</dt>
<dd>
<p>If enabled, <code>bazel test --run_under=//:runner</code> builds <code>//:runner</code> in the exec
configuration. If disabled, it builds <code>//:runner</code> in the target configuration.
Bazel executes tests on exec machines, so the former is more correct. This
doesn't affect <code>bazel run</code>, which always builds <code>--run_under=//foo</code> in the
target configuration.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_builtin_objc_strip_action"><code><a href="#flag--incompatible_builtin_objc_strip_action">--[no]incompatible_builtin_objc_strip_action</a></code> default: "true"</dt>
<dd>
<p>Whether to emit a strip action as part of objc linking.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_dont_enable_host_nonhost_crosstool_features"><code><a href="#flag--incompatible_dont_enable_host_nonhost_crosstool_features">--[no]incompatible_dont_enable_host_nonhost_crosstool_features</a></code> default: "true"</dt>
<dd>
<p>If true, Bazel will not enable 'host' and 'nonhost' features in the c++ toolchain (see https://github.com/bazelbuild/bazel/issues/7407 for more information).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_enable_apple_toolchain_resolution"><code><a href="#flag--incompatible_enable_apple_toolchain_resolution">--[no]incompatible_enable_apple_toolchain_resolution</a></code> default: "false"</dt>
<dd>
<p>Use toolchain resolution to select the Apple SDK for apple rules (Starlark and native)</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_remove_legacy_whole_archive"><code><a href="#flag--incompatible_remove_legacy_whole_archive">--[no]incompatible_remove_legacy_whole_archive</a></code> default: "true"</dt>
<dd>
<p>If true, Bazel will not link library dependencies as whole archive by default (see https://github.com/bazelbuild/bazel/issues/7362 for migration instructions).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_strip_executable_safely"><code><a href="#flag--incompatible_strip_executable_safely">--[no]incompatible_strip_executable_safely</a></code> default: "false"</dt>
<dd>
<p>If true, strip action for executables will use flag -x, which does not break dynamic symbol resolution.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--interface_shared_objects"><code><a href="#flag--interface_shared_objects">--[no]interface_shared_objects</a></code> default: "true"</dt>
<dd>
<p>Use interface shared objects if supported by the toolchain. All ELF toolchains currently support this setting.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ios_sdk_version"><code><a href="#flag--ios_sdk_version">--ios_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the iOS SDK to use to build iOS applications. If unspecified, uses the default iOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--macos_sdk_version"><code><a href="#flag--macos_sdk_version">--macos_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the macOS SDK to use to build macOS applications. If unspecified, uses the default macOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--minimum_os_version"><code><a href="#flag--minimum_os_version">--minimum_os_version</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The minimum OS version which your compilation targets.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--platform_mappings"><code><a href="#flag--platform_mappings">--platform_mappings</a>=&lt;a main workspace-relative path&gt;</code> default: ""</dt>
<dd>
<p>The location of a mapping file that describes which platform to use if none is set or
which flags to set when a platform already exists. Must be relative to the main
workspace root. Defaults to <code>platform_mappings</code> (a file directly under the
workspace root).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--platforms"><code><a href="#flag--platforms">--platforms</a>=&lt;a build target label&gt;</code> default: ""</dt>
<dd>
<p>The labels of the platform rules describing the target platforms for the current command.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--python_path"><code><a href="#flag--python_path">--python_path</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The absolute path of the Python interpreter invoked to run Python targets on the
target platform. Deprecated; disabled by <code>--incompatible_use_python_toolchains</code>.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--tvos_sdk_version"><code><a href="#flag--tvos_sdk_version">--tvos_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the tvOS SDK to use to build tvOS applications. If unspecified, uses the default tvOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--use_platforms_in_apple_crosstool_transition"><code><a href="#flag--use_platforms_in_apple_crosstool_transition">--[no]use_platforms_in_apple_crosstool_transition</a></code> default: "false"</dt>
<dd>
<p>Makes apple_crosstool_transition fall back to using the value of <code>--platforms</code> flag instead of legacy <code>--cpu</code> when needed.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--watchos_sdk_version"><code><a href="#flag--watchos_sdk_version">--watchos_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the watchOS SDK to use to build watchOS applications. If unspecified, uses the default watchOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--xcode_version"><code><a href="#flag--xcode_version">--xcode_version</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>If specified, uses Xcode of the given version for relevant build actions. If unspecified, uses the executor default version of Xcode.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--xcode_version_config"><code><a href="#flag--xcode_version_config">--xcode_version_config</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/cpp:host_xcodes"</dt>
<dd>
<p>The label of the xcode_config rule to be used for selecting the Xcode version in the build configuration.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
</dl>
<dl>Options that control the output of the command:
<dt id="flag--apple_generate_dsym"><code><a href="#flag--apple_generate_dsym">--[no]apple_generate_dsym</a></code> default: "false"</dt>
<dd>
<p>Whether to generate debug symbol(.dSYM) file(s).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--build_runfile_links"><code><a href="#flag--build_runfile_links">--[no]build_runfile_links</a></code> default: "true"</dt>
<dd>
<p>If true, build runfiles symlink forests for all targets.  If false, write them only when required by a local action, test or run command.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--build_runfile_manifests"><code><a href="#flag--build_runfile_manifests">--[no]build_runfile_manifests</a></code> default: "true"</dt>
<dd>
<p>If true, write runfiles manifests for all targets. If false, omit them. Local tests will fail to run when false.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--build_test_dwp"><code><a href="#flag--build_test_dwp">--[no]build_test_dwp</a></code> default: "false"</dt>
<dd>
<p>If enabled, when building C++ tests statically and with fission the .dwp file  for the test binary will be automatically built as well.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cc_proto_library_header_suffixes"><code><a href="#flag--cc_proto_library_header_suffixes">--cc_proto_library_header_suffixes</a>=&lt;comma-separated set of options&gt;</code> default: ".pb.h"</dt>
<dd>
<p>Sets the suffixes of header files that a cc_proto_library creates.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--cc_proto_library_source_suffixes"><code><a href="#flag--cc_proto_library_source_suffixes">--cc_proto_library_source_suffixes</a>=&lt;comma-separated set of options&gt;</code> default: ".pb.cc"</dt>
<dd>
<p>Sets the suffixes of source files that a cc_proto_library creates.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--experimental_proto_descriptor_sets_include_source_info"><code><a href="#flag--experimental_proto_descriptor_sets_include_source_info">--[no]experimental_proto_descriptor_sets_include_source_info</a></code> default: "false"</dt>
<dd>
<p>Run extra actions for alternative Java api versions in a proto_library.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_save_feature_state"><code><a href="#flag--experimental_save_feature_state">--[no]experimental_save_feature_state</a></code> default: "false"</dt>
<dd>
<p>Save the state of enabled and requested feautres as an output of compilation.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--fission"><code><a href="#flag--fission">--fission</a>=&lt;a set of compilation modes&gt;</code> default: "no"</dt>
<dd>
<p>Specifies which compilation modes use fission for C++ compilations and links.  May be any combination of {'fastbuild', 'dbg', 'opt'} or the special values 'yes'  to enable all modes and 'no' to disable all modes.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--incompatible_always_include_files_in_data"><code><a href="#flag--incompatible_always_include_files_in_data">--[no]incompatible_always_include_files_in_data</a></code> default: "true"</dt>
<dd>
<p>If true, native rules add <code>DefaultInfo.files</code> of data dependencies to their runfiles,
which matches the recommended behavior for Starlark rules (<a href="https://bazel.build/extending/rules#runfiles_features_to_avoid">runfiles features to avoid</a>).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_compact_repo_mapping_manifest"><code><a href="#flag--incompatible_compact_repo_mapping_manifest">--[no]incompatible_compact_repo_mapping_manifest</a></code> default: "false"</dt>
<dd>
<p>If enabled, the <code>{binary}.repo_mapping</code> file emits a module extension's repo mapping
only once instead of once for each repo generated by the extension that
contributes runfiles.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_disable_select_on"><code><a href="#flag--incompatible_disable_select_on">--incompatible_disable_select_on</a>=&lt;comma-separated set of options&gt;</code> default: ""</dt>
<dd>
<p>List of flags for which the use in <code>select()</code> is disabled.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--incompatible_filegroup_runfiles_for_data"><code><a href="#flag--incompatible_filegroup_runfiles_for_data">--[no]incompatible_filegroup_runfiles_for_data</a></code> default: "true"</dt>
<dd>
<p>If true, runfiles of targets listed in the srcs attribute are available to targets that consume the filegroup as a data dependency.</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--objc_generate_linkmap"><code><a href="#flag--objc_generate_linkmap">--[no]objc_generate_linkmap</a></code> default: "false"</dt>
<dd>
<p>Specifies whether to generate a linkmap file.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--save_temps"><code><a href="#flag--save_temps">--[no]save_temps</a></code> default: "false"</dt>
<dd>
<p>If set, temporary outputs from gcc will be saved.  These include .s files (assembler code), .i files (preprocessed C) and .ii files (preprocessed C++).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
</dl>
<dl>Options that let the user configure the intended output, affecting its value, as opposed to its existence:
<dt id="flag--action_env"><code><a href="#flag--action_env">--action_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the set of environment variables available to actions with target
configuration. Variables can be either specified by <code>name</code>, in which case
the value will be taken from the invocation environment, by the <code>name=value</code>
pair which sets the value independent of the invocation environment, or by
<code>=name</code>, which unsets the variable of that name. This option can be used
multiple times; for options given for the same variable, the latest wins,
options for different variables accumulate.</p>
<p>Note that unless <code>--incompatible_repo_env_ignores_action_env</code> is true, all <code>name=value</code>
pairs will be available to repository rules.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--allowed_cpu_values"><code><a href="#flag--allowed_cpu_values">--allowed_cpu_values</a>=&lt;comma-separated set of options&gt;</code> default: ""</dt>
<dd>
<p>Allowed values for the <code>--cpu</code> flag.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--android_databinding_use_androidx"><code><a href="#flag--android_databinding_use_androidx">--[no]android_databinding_use_androidx</a></code> default: "true"</dt>
<dd>
<p>Generate AndroidX-compatible data-binding files. This is only used with databinding v2. This flag is a no-op.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--android_databinding_use_v3_4_args"><code><a href="#flag--android_databinding_use_v3_4_args">--[no]android_databinding_use_v3_4_args</a></code> default: "true"</dt>
<dd>
<p>Use android databinding v2 with 3.4.0 argument. This flag is a no-op.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--android_dynamic_mode"><code><a href="#flag--android_dynamic_mode">--android_dynamic_mode</a>=&lt;off, default or fully&gt;</code> default: "off"</dt>
<dd>
<p>Determines whether C++ deps of Android rules will be linked dynamically when a cc_binary does not explicitly create a shared library. 'default' means bazel will choose whether to link dynamically.  'fully' means all libraries will be linked dynamically. 'off' means that all libraries will be linked in mostly static mode.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--android_manifest_merger_order"><code><a href="#flag--android_manifest_merger_order">--android_manifest_merger_order</a>=&lt;alphabetical, alphabetical_by_configuration or dependency&gt;</code> default: "alphabetical"</dt>
<dd>
<p>Sets the order of manifests passed to the manifest merger for Android binaries. ALPHABETICAL means manifests are sorted by path relative to the execroot. ALPHABETICAL_BY_CONFIGURATION means manifests are sorted by paths relative to the configuration directory within the output directory. DEPENDENCY means manifests are ordered with each library's manifest coming before the manifests of its dependencies.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--android_resource_shrinking"><code><a href="#flag--android_resource_shrinking">--[no]android_resource_shrinking</a></code> default: "false"</dt>
<dd>
<p>Enables resource shrinking for android_binary APKs that use ProGuard.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--build_python_zip"><code><a href="#flag--build_python_zip">--[no]build_python_zip</a></code> default: "auto"</dt>
<dd>
<p>Build python executable zip; on on Windows, off on other platforms</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--catalyst_cpus"><code><a href="#flag--catalyst_cpus">--catalyst_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple Catalyst binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--collect_code_coverage"><code><a href="#flag--collect_code_coverage">--[no]collect_code_coverage</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will instrument code (using offline instrumentation where
possible) and will collect coverage information during tests. Only targets that
match <code>--instrumentation_filter</code> will be affected. Usually this option should
not be specified directly - <code>bazel coverage</code> command should be used instead.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--compilation_mode"><code><a href="#flag--compilation_mode">--compilation_mode</a>=&lt;fastbuild, dbg or opt&gt;</code> [<code>-c</code>] default: "fastbuild"</dt>
<dd>
<p>Specify the mode the binary will be built in. Values: <code>fastbuild</code>, <code>dbg</code>, <code>opt</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--conlyopt"><code><a href="#flag--conlyopt">--conlyopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to gcc when compiling C source files.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--copt"><code><a href="#flag--copt">--copt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to gcc.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cpu"><code><a href="#flag--cpu">--cpu</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Deprecated: this flag is not used internally by Blaze although there are legacy platform
mappings to allow for backwards compatibility. Do not use this flag, instead use
<code>--platforms</code> with an appropriate platform definition.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cs_fdo_absolute_path"><code><a href="#flag--cs_fdo_absolute_path">--cs_fdo_absolute_path</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Use CSFDO profile information to optimize compilation. Specify the absolute path name of the zip file containing the profile file, a raw or an indexed LLVM profile file.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cs_fdo_instrument"><code><a href="#flag--cs_fdo_instrument">--cs_fdo_instrument</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Generate binaries with context sensitive FDO instrumentation. With Clang/LLVM compiler, it also accepts the directory name under which the raw profile file(s) will be dumped at runtime.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cs_fdo_profile"><code><a href="#flag--cs_fdo_profile">--cs_fdo_profile</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The cs_fdo_profile representing the context sensitive profile to be used for optimization.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cxxopt"><code><a href="#flag--cxxopt">--cxxopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to gcc when compiling C++ source files.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--define"><code><a href="#flag--define">--define</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Each <code>--define</code> option specifies an assignment for a build variable.
In case of multiple values for a variable, the last one wins.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--dynamic_mode"><code><a href="#flag--dynamic_mode">--dynamic_mode</a>=&lt;off, default or fully&gt;</code> default: "default"</dt>
<dd>
<p>Determines whether C++ binaries will be linked dynamically.  'default' means Bazel will choose whether to link dynamically.  'fully' means all libraries will be linked dynamically. 'off' means that all libraries will be linked in mostly static mode.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--enable_propeller_optimize_absolute_paths"><code><a href="#flag--enable_propeller_optimize_absolute_paths">--[no]enable_propeller_optimize_absolute_paths</a></code> default: "true"</dt>
<dd>
<p>If set, any use of absolute paths for propeller optimize will raise an error.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--enable_remaining_fdo_absolute_paths"><code><a href="#flag--enable_remaining_fdo_absolute_paths">--[no]enable_remaining_fdo_absolute_paths</a></code> default: "true"</dt>
<dd>
<p>If set, any use of absolute paths for FDO will raise an error.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--enable_runfiles"><code><a href="#flag--enable_runfiles">--[no]enable_runfiles</a></code> default: "auto"</dt>
<dd>
<p>Enable runfiles symlink tree; By default, it's off on Windows, on on other platforms.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--exec_aspects"><code><a href="#flag--exec_aspects">--exec_aspects</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of aspects to be applied to exec-configured targets, regardless of whether or not they are top-level targets. This is an experimental feature and is subject to change.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--experimental_action_listener"><code><a href="#flag--experimental_action_listener">--experimental_action_listener</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Deprecated in favor of aspects. Use <code>action_listener</code> to attach an <code>extra_action</code> to
existing build actions.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_compress_java_resources"><code><a href="#flag--experimental_android_compress_java_resources">--[no]experimental_android_compress_java_resources</a></code> default: "false"</dt>
<dd>
<p>Compress Java resources in APKs</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_databinding_v2"><code><a href="#flag--experimental_android_databinding_v2">--[no]experimental_android_databinding_v2</a></code> default: "true"</dt>
<dd>
<p>Use android databinding v2. This flag is a no-op.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_resource_shrinking"><code><a href="#flag--experimental_android_resource_shrinking">--[no]experimental_android_resource_shrinking</a></code> default: "false"</dt>
<dd>
<p>Enables resource shrinking for android_binary APKs that use ProGuard.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_rewrite_dexes_with_rex"><code><a href="#flag--experimental_android_rewrite_dexes_with_rex">--[no]experimental_android_rewrite_dexes_with_rex</a></code> default: "false"</dt>
<dd>
<p>use rex tool to rewrite dex files</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_collect_code_coverage_for_generated_files"><code><a href="#flag--experimental_collect_code_coverage_for_generated_files">--[no]experimental_collect_code_coverage_for_generated_files</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will also generate collect coverage information for generated files.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_objc_fastbuild_options"><code><a href="#flag--experimental_objc_fastbuild_options">--experimental_objc_fastbuild_options</a>=&lt;comma-separated list of options&gt;</code> default: "-O0,-DDEBUG=1"</dt>
<dd>
<p>Uses these strings as objc fastbuild compiler options.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--experimental_omitfp"><code><a href="#flag--experimental_omitfp">--[no]experimental_omitfp</a></code> default: "false"</dt>
<dd>
<p>If true, use libunwind for stack unwinding, and compile with -fomit-frame-pointer and -fasynchronous-unwind-tables.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_output_paths"><code><a href="#flag--experimental_output_paths">--experimental_output_paths</a>=&lt;off or strip&gt;</code> default: "off"</dt>
<dd>
<p>Which model to use for where in the output tree rules write their outputs, particularly
for multi-platform / multi-configuration builds. This is highly experimental. See
<a href="https://github.com/bazelbuild/bazel/issues/6526">GH-6526</a> for details. Starlark actions can opt into path mapping by adding the key
<code>supports-path-mapping</code> to the <code>execution_requirements</code> dict.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--experimental_override_platform_cpu_name"><code><a href="#flag--experimental_override_platform_cpu_name">--experimental_override_platform_cpu_name</a>=&lt;a &#39;label=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Each entry should be of the form <code>label=value</code> where label refers to a platform and values
is the desired shortname to override the platform's CPU name in <code>$(TARGET_CPU)</code>
make variable and output path. Only used when
<code>--experimental_platform_in_output_dir</code>, <code>--incompatible_target_cpu_from_platform</code> or
<code>--incompatible_bep_cpu_from_platform</code> is true. Has highest naming priority.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_platform_in_output_dir"><code><a href="#flag--experimental_platform_in_output_dir">--[no]experimental_platform_in_output_dir</a></code> default: "Auto"</dt>
<dd>
<p>If true, a shortname for the target platform is used in the output directory name
instead of the CPU. The exact scheme is experimental and subject to change:</p>
<ol>
<li>First, in the rare case the <code>--platforms</code> option does not have exactly one value, a
hash of the platforms option is used.</li>
<li>Next, if any shortname for the current platform was registered by
<code>--experimental_override_name_platform_in_output_dir</code>, then that shortname is used.</li>
<li>Then, if <code>--experimental_use_platforms_in_output_dir_legacy_heuristic</code> is set, use a
shortname based off the current platform Label.</li>
<li>Finally, a hash of the platform option is used as a last resort.</li>
</ol>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_py_binaries_include_label"><code><a href="#flag--experimental_py_binaries_include_label">--[no]experimental_py_binaries_include_label</a></code> default: "false"</dt>
<dd>
<p>py_binary targets include their label even when stamping is disabled.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_use_llvm_covmap"><code><a href="#flag--experimental_use_llvm_covmap">--[no]experimental_use_llvm_covmap</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will generate llvm-cov coverage map information rather than gcov when collect_code_coverage is enabled.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_use_platforms_in_output_dir_legacy_heuristic"><code><a href="#flag--experimental_use_platforms_in_output_dir_legacy_heuristic">--[no]experimental_use_platforms_in_output_dir_legacy_heuristic</a></code> default: "true"</dt>
<dd>
<p>Please only use this flag as part of a suggested migration or testing strategy. Note
that the heuristic has known deficiencies and it is suggested to migrate to
relying on just <code>--experimental_override_name_platform_in_output_dir</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--fdo_instrument"><code><a href="#flag--fdo_instrument">--fdo_instrument</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Generate binaries with FDO instrumentation. With Clang/LLVM compiler, it also accepts the directory name under which the raw profile file(s) will be dumped at runtime.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--fdo_optimize"><code><a href="#flag--fdo_optimize">--fdo_optimize</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Use FDO profile information to optimize compilation. Specify the name of a zip file containing a .gcda file tree, an afdo file containing an auto profile, or an LLVM profile file. This flag also accepts files specified as labels (e.g. <code>//foo/bar:file.afdo</code> - you may need to add an <code>exports_files</code> directive to the corresponding package) and labels pointing to <code>fdo_profile</code> targets. This flag will be superseded by the <code>fdo_profile</code> rule.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--fdo_prefetch_hints"><code><a href="#flag--fdo_prefetch_hints">--fdo_prefetch_hints</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use cache prefetch hints.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--fdo_profile"><code><a href="#flag--fdo_profile">--fdo_profile</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The fdo_profile representing the profile to be used for optimization.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--features"><code><a href="#flag--features">--features</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The given features will be enabled or disabled by default for targets built in the target configuration.
Specifying <code>-{feature}</code> will disable the feature. Negative features always override positive ones.
See also <code>--host_features</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--force_pic"><code><a href="#flag--force_pic">--[no]force_pic</a></code> default: "false"</dt>
<dd>
<p>If enabled, all C++ compilations produce position-independent code (&quot;-fPIC&quot;), links prefer PIC pre-built libraries over non-PIC libraries, and links produce position-independent executables (&quot;-pie&quot;).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_action_env"><code><a href="#flag--host_action_env">--host_action_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the set of environment variables available to actions with execution
configurations. Variables can be either specified by <code>name</code>, in which case the
value will be taken from the invocation environment, by the <code>name=value</code> pair
which sets the value independent of the invocation environment, or by
<code>=name</code>, which unsets the variable of that name. This option can
be used multiple times; for options given for the same variable, the latest
wins, options for different variables accumulate.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--host_compilation_mode"><code><a href="#flag--host_compilation_mode">--host_compilation_mode</a>=&lt;fastbuild, dbg or opt&gt;</code> default: "opt"</dt>
<dd>
<p>Specify the mode the tools used during the build will be built in. Values:
<code>fastbuild</code>, <code>dbg</code>, <code>opt</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--host_conlyopt"><code><a href="#flag--host_conlyopt">--host_conlyopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to the C compiler when compiling C (but not C++) source files in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_copt"><code><a href="#flag--host_copt">--host_copt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the C compiler for tools built in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_cpu"><code><a href="#flag--host_cpu">--host_cpu</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The host CPU.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_cxxopt"><code><a href="#flag--host_cxxopt">--host_cxxopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to C++ compiler for tools built in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_features"><code><a href="#flag--host_features">--host_features</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The given features will be enabled or disabled by default for targets built in the exec configuration.
Specifying <code>-{feature}</code> will disable the feature. Negative features always override positive ones.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_linkopt"><code><a href="#flag--host_linkopt">--host_linkopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to linker when linking tools in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_macos_minimum_os"><code><a href="#flag--host_macos_minimum_os">--host_macos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible macOS version for host targets. If unspecified, uses 'macos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--host_per_file_copt"><code><a href="#flag--host_per_file_copt">--host_per_file_copt</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths followed by an @ and a comma separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to selectively pass to the C/C++ compiler when compiling certain files in the exec configurations. This option can be passed multiple times. Syntax: regex_filter@option_1,option_2,...,option_n. Where regex_filter stands for a list of include and exclude regular expression patterns (Also see --instrumentation_filter). option_1 to option_n stand for arbitrary command line options. If an option contains a comma it has to be quoted with a backslash. Options can contain @. Only the first @ is used to split the string. Example: --host_per_file_copt=//foo/.*.cc,-//foo/bar.cc@-O0 adds the -O0 command line option to the gcc command line of all cc files in //foo/ except bar.cc.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--incompatible_auto_exec_groups"><code><a href="#flag--incompatible_auto_exec_groups">--[no]incompatible_auto_exec_groups</a></code> default: "false"</dt>
<dd>
<p>When enabled, an exec groups is automatically created for each toolchain used by a rule.
For this to work rule needs to specify <code>toolchain</code> parameter on its actions. For
more information, see <a href="https://github.com/bazelbuild/bazel/issues/17134">GH-17134</a>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_merge_genfiles_directory"><code><a href="#flag--incompatible_merge_genfiles_directory">--[no]incompatible_merge_genfiles_directory</a></code> default: "true"</dt>
<dd>
<p>If true, the genfiles directory is folded into the bin directory.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_target_cpu_from_platform"><code><a href="#flag--incompatible_target_cpu_from_platform">--[no]incompatible_target_cpu_from_platform</a></code> default: "true"</dt>
<dd>
<p>If specified, the value of the cpu constraint (<code>@platforms//cpu:cpu</code>) of
the target platform is used to set the <code>$(TARGET_CPU)</code> make variable.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--instrument_test_targets"><code><a href="#flag--instrument_test_targets">--[no]instrument_test_targets</a></code> default: "false"</dt>
<dd>
<p>When coverage is enabled, specifies whether to consider instrumenting test rules.
When set, test rules included by <code>--instrumentation_filter</code> are instrumented.
Otherwise, test rules are always excluded from coverage instrumentation.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--instrumentation_filter"><code><a href="#flag--instrumentation_filter">--instrumentation_filter</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths&gt;</code> default: "-/javatests[/:],-/test/java[/:]"</dt>
<dd>
<p>When coverage is enabled, only rules with names included by the
specified regex-based filter will be instrumented. Rules prefixed
with '-' are excluded instead. Note that only non-test rules are
instrumented unless <code>--instrument_test_targets</code> is enabled.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ios_minimum_os"><code><a href="#flag--ios_minimum_os">--ios_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible iOS version for target simulators and devices. If unspecified, uses 'ios_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--ios_multi_cpus"><code><a href="#flag--ios_multi_cpus">--ios_multi_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures to build an ios_application with. The result is a universal binary containing all specified architectures.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--legacy_whole_archive"><code><a href="#flag--legacy_whole_archive">--[no]legacy_whole_archive</a></code> default: "true"</dt>
<dd>
<p>Deprecated, superseded by --incompatible_remove_legacy_whole_archive (see https://github.com/bazelbuild/bazel/issues/7362 for details). When on, use --whole-archive for cc_binary rules that have linkshared=True and either linkstatic=True or '-static' in linkopts. This is for backwards compatibility only. A better alternative is to use alwayslink=1 where required.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_DEPRECATED"><code>deprecated</code></a>
</p></dd>
<dt id="flag--linkopt"><code><a href="#flag--linkopt">--linkopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to gcc when linking.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ltobackendopt"><code><a href="#flag--ltobackendopt">--ltobackendopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to the LTO backend step (under --features=thin_lto).</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ltoindexopt"><code><a href="#flag--ltoindexopt">--ltoindexopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to the LTO indexing step (under --features=thin_lto).</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--macos_cpus"><code><a href="#flag--macos_cpus">--macos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple macOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--macos_minimum_os"><code><a href="#flag--macos_minimum_os">--macos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible macOS version for targets. If unspecified, uses 'macos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--memprof_profile"><code><a href="#flag--memprof_profile">--memprof_profile</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use memprof profile.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--objc_debug_with_GLIBCXX"><code><a href="#flag--objc_debug_with_GLIBCXX">--[no]objc_debug_with_GLIBCXX</a></code> default: "false"</dt>
<dd>
<p>If set, and compilation mode is set to 'dbg', define GLIBCXX_DEBUG,  GLIBCXX_DEBUG_PEDANTIC and GLIBCPP_CONCEPT_CHECKS.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--objc_enable_binary_stripping"><code><a href="#flag--objc_enable_binary_stripping">--[no]objc_enable_binary_stripping</a></code> default: "false"</dt>
<dd>
<p>Whether to perform symbol and dead-code strippings on linked binaries. Binary strippings will be performed if both this flag and --compilation_mode=opt are specified.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--objccopt"><code><a href="#flag--objccopt">--objccopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to gcc when compiling Objective-C/C++ source files.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--per_file_copt"><code><a href="#flag--per_file_copt">--per_file_copt</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths followed by an @ and a comma separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to selectively pass to gcc when compiling certain files. This option can be passed multiple times. Syntax: regex_filter@option_1,option_2,...,option_n. Where regex_filter stands for a list of include and exclude regular expression patterns (Also see --instrumentation_filter). option_1 to option_n stand for arbitrary command line options. If an option contains a comma it has to be quoted with a backslash. Options can contain @. Only the first @ is used to split the string. Example: --per_file_copt=//foo/.*.cc,-//foo/bar.cc@-O0 adds the -O0 command line option to the gcc command line of all cc files in //foo/ except bar.cc.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--per_file_ltobackendopt"><code><a href="#flag--per_file_ltobackendopt">--per_file_ltobackendopt</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths followed by an @ and a comma separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to selectively pass to LTO backend (under --features=thin_lto) when compiling certain backend objects. This option can be passed multiple times. Syntax: regex_filter@option_1,option_2,...,option_n. Where regex_filter stands for a list of include and exclude regular expression patterns. option_1 to option_n stand for arbitrary command line options. If an option contains a comma it has to be quoted with a backslash. Options can contain @. Only the first @ is used to split the string. Example: --per_file_ltobackendopt=//foo/.*.o,-//foo/bar.o@-O0 adds the -O0 command line option to the LTO backend command line of all o files in //foo/ except bar.o.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--platform_suffix"><code><a href="#flag--platform_suffix">--platform_suffix</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specifies a suffix to be added to the configuration directory.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--propeller_optimize"><code><a href="#flag--propeller_optimize">--propeller_optimize</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use Propeller profile information to optimize the build target.A propeller profile must consist of at least one of two files, a cc profile and a ld profile.  This flag accepts a build label which must refer to the propeller profile input files. For example, the BUILD file that defines the label, in a/b/BUILD:propeller_optimize(    name = &quot;propeller_profile&quot;,    cc_profile = &quot;propeller_cc_profile.txt&quot;,    ld_profile = &quot;propeller_ld_profile.txt&quot;,)An exports_files directive may have to be added to the corresponding package to make these files visible to Bazel. The option must be used as: --propeller_optimize=//a/b:propeller_profile</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--propeller_optimize_absolute_cc_profile"><code><a href="#flag--propeller_optimize_absolute_cc_profile">--propeller_optimize_absolute_cc_profile</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Absolute path name of cc_profile file for Propeller Optimized builds.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--propeller_optimize_absolute_ld_profile"><code><a href="#flag--propeller_optimize_absolute_ld_profile">--propeller_optimize_absolute_ld_profile</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Absolute path name of ld_profile file for Propeller Optimized builds.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--run_under"><code><a href="#flag--run_under">--run_under</a>=&lt;a prefix in front of command&gt;</code> default: see description</dt>
<dd>
<p>Prefix to insert before the executables for the <code>test</code> and <code>run</code> commands.
If the value is <code>foo -bar</code>, and the execution command line is <code>test_binary -baz</code>,
then the final command line is <code>foo -bar test_binary -baz</code>.
This can also be a label to an executable target. Some examples are:</p>
<ul>
<li><code>valgrind</code></li>
<li><code>strace</code></li>
<li><code>strace -c</code></li>
<li><code>valgrind --quiet --num-callers=20</code></li>
<li><code>//package:target</code></li>
<li><code>//package:target --options</code></li>
</ul>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--share_native_deps"><code><a href="#flag--share_native_deps">--[no]share_native_deps</a></code> default: "true"</dt>
<dd>
<p>If true, native libraries that contain identical functionality will be shared among different targets</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--stamp"><code><a href="#flag--stamp">--[no]stamp</a></code> default: "false"</dt>
<dd>
<p>Stamp binaries with the date, username, hostname, workspace information, etc.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--strip"><code><a href="#flag--strip">--strip</a>=&lt;always, sometimes or never&gt;</code> default: "sometimes"</dt>
<dd>
<p>Specifies whether to strip binaries and shared libraries  (using &quot;-Wl,--strip-debug&quot;).  The default value of 'sometimes' means strip iff --compilation_mode=fastbuild.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--stripopt"><code><a href="#flag--stripopt">--stripopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to strip when generating a '&lt;name&gt;.stripped' binary.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--tvos_cpus"><code><a href="#flag--tvos_cpus">--tvos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple tvOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--tvos_minimum_os"><code><a href="#flag--tvos_minimum_os">--tvos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible tvOS version for target simulators and devices. If unspecified, uses 'tvos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--visionos_cpus"><code><a href="#flag--visionos_cpus">--visionos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple visionOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--watchos_cpus"><code><a href="#flag--watchos_cpus">--watchos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple watchOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--watchos_minimum_os"><code><a href="#flag--watchos_minimum_os">--watchos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible watchOS version for target simulators and devices. If unspecified, uses 'watchos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--xbinary_fdo"><code><a href="#flag--xbinary_fdo">--xbinary_fdo</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use XbinaryFDO profile information to optimize compilation. Specify the name of default cross binary profile. When the option is used together with --fdo_instrument/--fdo_optimize/--fdo_profile, those options will always prevail as if xbinary_fdo is never specified.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
</dl>
<dl>Options that affect how strictly Bazel enforces valid build inputs (rule definitions,  flag combinations, etc.):
<dt id="flag--check_visibility"><code><a href="#flag--check_visibility">--[no]check_visibility</a></code> default: "true"</dt>
<dd>
<p>If disabled, visibility errors in target dependencies are demoted to warnings.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--desugar_for_android"><code><a href="#flag--desugar_for_android">--[no]desugar_for_android</a></code> default: "true"</dt>
<dd>
<p>Whether to desugar Java 8 bytecode before dexing.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--desugar_java8_libs"><code><a href="#flag--desugar_java8_libs">--[no]desugar_java8_libs</a></code> default: "false"</dt>
<dd>
<p>Whether to include supported Java 8 libraries in apps for legacy devices.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--enforce_constraints"><code><a href="#flag--enforce_constraints">--[no]enforce_constraints</a></code> default: "true"</dt>
<dd>
<p>Checks the environments each target is compatible with and reports errors if any target has dependencies that don't support the same environments</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="flag--experimental_check_desugar_deps"><code><a href="#flag--experimental_check_desugar_deps">--[no]experimental_check_desugar_deps</a></code> default: "true"</dt>
<dd>
<p>Whether to double-check correct desugaring at Android binary level.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_enforce_transitive_visibility"><code><a href="#flag--experimental_enforce_transitive_visibility">--[no]experimental_enforce_transitive_visibility</a></code> default: "false"</dt>
<dd>
<p>If true, enable package()s to set the transitive_visibility attribute to restrict which packages may depend on them.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_one_version_enforcement"><code><a href="#flag--experimental_one_version_enforcement">--experimental_one_version_enforcement</a>=&lt;off, warning or error&gt;</code> default: "OFF"</dt>
<dd>
<p>When enabled, enforce that a java_binary rule can't contain more than one version of the same class file on the classpath. This enforcement can break the build, or can just result in warnings.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--experimental_strict_java_deps"><code><a href="#flag--experimental_strict_java_deps">--experimental_strict_java_deps</a>=&lt;off, warn, error, strict or default&gt;</code> default: "default"</dt>
<dd>
<p>If true, checks that a Java target explicitly declares all directly used targets as dependencies.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="flag--incompatible_check_testonly_for_output_files"><code><a href="#flag--incompatible_check_testonly_for_output_files">--[no]incompatible_check_testonly_for_output_files</a></code> default: "false"</dt>
<dd>
<p>If enabled, check testonly for prerequisite targets that are output files by looking up the testonly of the generating rule. This matches visibility checking.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_disable_native_android_rules"><code><a href="#flag--incompatible_disable_native_android_rules">--[no]incompatible_disable_native_android_rules</a></code> default: "false"</dt>
<dd>
<p>If enabled, direct usage of the native Android rules is disabled. Please use the Starlark Android rules from https://github.com/bazelbuild/rules_android</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_disable_native_apple_binary_rule"><code><a href="#flag--incompatible_disable_native_apple_binary_rule">--[no]incompatible_disable_native_apple_binary_rule</a></code> default: "false"</dt>
<dd>
<p>No-op. Kept here for backwards compatibility.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--one_version_enforcement_on_java_tests"><code><a href="#flag--one_version_enforcement_on_java_tests">--[no]one_version_enforcement_on_java_tests</a></code> default: "true"</dt>
<dd>
<p>When enabled, and with experimental_one_version_enforcement set to a non-NONE value, enforce one version on java_test targets. This flag can be disabled to improve incremental test performance at the expense of missing potential one version violations.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--python_native_rules_allowlist"><code><a href="#flag--python_native_rules_allowlist">--python_native_rules_allowlist</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>An allowlist (package_group target) to use when enforcing --incompatible_python_disallow_native_rules.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--strict_filesets"><code><a href="#flag--strict_filesets">--[no]strict_filesets</a></code> default: "false"</dt>
<dd>
<p>If this option is enabled, filesets crossing package boundaries are reported as errors.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="flag--strict_proto_deps"><code><a href="#flag--strict_proto_deps">--strict_proto_deps</a>=&lt;off, warn, error, strict or default&gt;</code> default: "error"</dt>
<dd>
<p>Unless OFF, checks that a proto_library target explicitly declares all directly used targets as dependencies.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--strict_public_imports"><code><a href="#flag--strict_public_imports">--strict_public_imports</a>=&lt;off, warn, error, strict or default&gt;</code> default: "off"</dt>
<dd>
<p>Unless OFF, checks that a proto_library target explicitly declares all targets used in 'import public' as exported.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--strict_system_includes"><code><a href="#flag--strict_system_includes">--[no]strict_system_includes</a></code> default: "false"</dt>
<dd>
<p>If true, headers found through system include paths (-isystem) are also required to be declared.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="flag--target_environment"><code><a href="#flag--target_environment">--target_environment</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Declares this build's target environment. Must be a label reference to an
<a href="https://github.com/bazelbuild/bazel/blob/master/src/main/java/com/google/devtools/build/lib/analysis/constraints/EnvironmentRule.java"><code>environment</code> rule</a>. If specified, all top-level targets must be compatible with this
environment.</p>
<p>See also <code>--platforms</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
</dl>
<dl>Options that affect the signing outputs of a build:
<dt id="flag--apk_signing_method"><code><a href="#flag--apk_signing_method">--apk_signing_method</a>=&lt;v1, v2, v1_v2 or v4&gt;</code> default: "v1_v2"</dt>
<dd>
<p>Implementation to use to sign APKs</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--device_debug_entitlements"><code><a href="#flag--device_debug_entitlements">--[no]device_debug_entitlements</a></code> default: "true"</dt>
<dd>
<p>If set, and compilation mode is not 'opt', objc apps will include debug entitlements when signing.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="flag--ios_signing_cert_name"><code><a href="#flag--ios_signing_cert_name">--ios_signing_cert_name</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Certificate name to use for iOS signing. If not set will fall back to provisioning profile. May be the certificate's keychain identity preference or (substring) of the certificate's common name, as per codesign's man page (SIGNING IDENTITIES).</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
</dl>
<dl>This option affects semantics of the Starlark language or the build API accessible to BUILD files, .bzl files, or WORKSPACE files.:
<dt id="flag--incompatible_disallow_sdk_frameworks_attributes"><code><a href="#flag--incompatible_disallow_sdk_frameworks_attributes">--[no]incompatible_disallow_sdk_frameworks_attributes</a></code> default: "false"</dt>
<dd>
<p>If true, disallow sdk_frameworks and weak_sdk_frameworks attributes in objc_library andobjc_import.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_objc_alwayslink_by_default"><code><a href="#flag--incompatible_objc_alwayslink_by_default">--[no]incompatible_objc_alwayslink_by_default</a></code> default: "false"</dt>
<dd>
<p>If true, make the default value true for alwayslink attributes in objc_library and objc_import.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_python_disallow_native_rules"><code><a href="#flag--incompatible_python_disallow_native_rules">--[no]incompatible_python_disallow_native_rules</a></code> default: "false"</dt>
<dd>
<p>When true, an error occurs when using the builtin py_* rules; instead the rule_python rules should be used. See https://github.com/bazelbuild/bazel/issues/17773 for more information and migration instructions.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options that govern the behavior of the test environment or test runner:
<dt id="flag--allow_analysis_failures"><code><a href="#flag--allow_analysis_failures">--[no]allow_analysis_failures</a></code> default: "false"</dt>
<dd>
<p>If true, an analysis failure of a rule target results in the target's propagation
of an instance of <code>AnalysisFailureInfo</code> containing the error description, instead
of resulting in a build failure.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--analysis_testing_deps_limit"><code><a href="#flag--analysis_testing_deps_limit">--analysis_testing_deps_limit</a>=&lt;an integer&gt;</code> default: "2000"</dt>
<dd>
<p>Sets the maximum number of transitive dependencies through a rule attribute with
a <code>for_analysis_testing</code> configuration transition.
Exceeding this limit will result in a rule error.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--break_build_on_parallel_dex2oat_failure"><code><a href="#flag--break_build_on_parallel_dex2oat_failure">--[no]break_build_on_parallel_dex2oat_failure</a></code> default: "false"</dt>
<dd>
<p>If true dex2oat action failures will cause the build to break instead of executing dex2oat during test runtime.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--default_test_resources"><code><a href="#flag--default_test_resources">--default_test_resources</a>=&lt;a resource name followed by equal and 1 float or 4 float, e.g memory=10,30,60,100&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Override the default resources amount for tests. The expected format is
<code>{resource}={value}</code>. If a single positive number is specified as <code>{value}</code>
it will override the default resources for all test sizes. If 4
comma-separated numbers are specified, they will override the resource
amount for respectively the <code>small</code>, <code>medium</code>, <code>large</code>, <code>enormous</code> test sizes.
Values can also be <code>HOST_RAM</code>/<code>HOST_CPU</code>, optionally followed
by <code>[-|*]{float}</code> (eg. <code>memory=HOST_RAM*.1,HOST_RAM*.2,HOST_RAM*.3,HOST_RAM*.4</code>).
The default test resources specified by this flag are overridden by explicit
resources specified in tags.</p>
</dd>
<dt id="flag--experimental_android_use_parallel_dex2oat"><code><a href="#flag--experimental_android_use_parallel_dex2oat">--[no]experimental_android_use_parallel_dex2oat</a></code> default: "false"</dt>
<dd>
<p>Use dex2oat in parallel to possibly speed up android_test.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--ios_memleaks"><code><a href="#flag--ios_memleaks">--[no]ios_memleaks</a></code> default: "false"</dt>
<dd>
<p>Enable checking for memory leaks in ios_test targets.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--ios_simulator_device"><code><a href="#flag--ios_simulator_device">--ios_simulator_device</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The device to simulate when running an iOS application in the simulator, e.g. 'iPhone 6'. You can get a list of devices by running 'xcrun simctl list devicetypes' on the machine the simulator will be run on.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
<dt id="flag--ios_simulator_version"><code><a href="#flag--ios_simulator_version">--ios_simulator_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>The version of iOS to run on the simulator when running or testing. This is ignored for ios_test rules if a target device is specified in the rule.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
<dt id="flag--runs_per_test"><code><a href="#flag--runs_per_test">--runs_per_test</a>=&lt;a positive integer or test_regex@runs. This flag may be passed more than once&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies number of times to run each test. If any of those attempts fail for any
reason, the whole test is considered failed. Normally the value specified is
just an integer.</p>
<p>Example: <code>--runs_per_test=3</code> will run all tests 3 times.</p>
<p>Alternate syntax: <code>regex_filter@runs_per_test</code>. Where <code>runs_per_test</code> stands for
an integer value and <code>regex_filter</code> stands for a list of include and exclude
regular expression patterns (Also see --instrumentation_filter).</p>
<p>Example: <code>--runs_per_test=//foo/.*,-//foo/bar/.*@3</code> runs all tests in <code>//foo/</code> except
those under <code>//foo/bar</code> three times. This option can be passed multiple times. The most
recently passed argument that matches takes precedence. If nothing matches,
the test is only run once.</p>
</dd>
<dt id="flag--test_env"><code><a href="#flag--test_env">--test_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies additional environment variables to be injected into the test runner
environment. Variables can be either specified by <code>name</code>, in which
case its value will be read from the Bazel client environment, or by the
<code>name=value</code> pair.
Previously set variables can be unset via <code>=name</code>.
This option can be used multiple times to specify several variables.
Used only by the 'bazel test' command.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
<dt id="flag--test_timeout"><code><a href="#flag--test_timeout">--test_timeout</a>=&lt;a single integer or comma-separated list of 4 integers&gt;</code> default: "-1"</dt>
<dd>
<p>Override the default test timeout values for test timeouts (in secs). If a single
positive integer value is specified it will override all categories.  If 4
comma-separated integers are specified, they will override the timeouts for
<code>short</code>, <code>moderate</code>, <code>long</code> and <code>eternal</code> (in that order). In either form, a value of
-1 tells blaze to use its default timeouts for that category.</p>
</dd>
<dt id="flag--zip_undeclared_test_outputs"><code><a href="#flag--zip_undeclared_test_outputs">--[no]zip_undeclared_test_outputs</a></code> default: "false"</dt>
<dd>
<p>If true, undeclared test outputs will be archived in a zip file.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
</dl>
<dl>Options that trigger optimizations of the build time:
<dt id="flag--cc_dotd_files"><code><a href="#flag--cc_dotd_files">--[no]cc_dotd_files</a></code> default: "true"</dt>
<dd>
<p>Whether to generate and analyze .d files.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="flag--cc_include_scanning"><code><a href="#flag--cc_include_scanning">--[no]cc_include_scanning</a></code> default: "false"</dt>
<dd>
<p>Whether to narrow inputs to C/C++ compilation by parsing #include lines from input files. This can improve performance and incrementality by decreasing the size of compilation input trees. However, it can also break builds because the include scanner does not fully implement C preprocessor semantics. In particular, it does not understand dynamic #include directives and ignores preprocessor conditional logic. Use at your own risk. Any issues relating to this flag that are filed will be closed. At Google without this flag your build will most likely fail.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_filter_library_jar_with_program_jar"><code><a href="#flag--experimental_filter_library_jar_with_program_jar">--[no]experimental_filter_library_jar_with_program_jar</a></code> default: "false"</dt>
<dd>
<p>Filter the ProGuard ProgramJar to remove any classes also present in the LibraryJar.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_inmemory_dotd_files"><code><a href="#flag--experimental_inmemory_dotd_files">--[no]experimental_inmemory_dotd_files</a></code> default: "true"</dt>
<dd>
<p>If enabled, C++ .d files will be passed through in memory directly from the remote build nodes instead of being written to disk.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_inmemory_jdeps_files"><code><a href="#flag--experimental_inmemory_jdeps_files">--[no]experimental_inmemory_jdeps_files</a></code> default: "true"</dt>
<dd>
<p>If enabled, the dependency (.jdeps) files generated from Java compilations will be passed through in memory directly from the remote build nodes instead of being written to disk.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_retain_test_configuration_across_testonly"><code><a href="#flag--experimental_retain_test_configuration_across_testonly">--[no]experimental_retain_test_configuration_across_testonly</a></code> default: "false"</dt>
<dd>
<p>When enabled, <code>--trim_test_configuration</code> will not trim the test configuration for rules
marked testonly=1. This is meant to reduce action conflict issues when non-test
rules depend on <code>cc_test</code> rules. No effect if <code>--trim_test_configuration</code> is
false.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_unsupported_and_brittle_include_scanning"><code><a href="#flag--experimental_unsupported_and_brittle_include_scanning">--[no]experimental_unsupported_and_brittle_include_scanning</a></code> default: "false"</dt>
<dd>
<p>Whether to narrow inputs to C/C++ compilation by parsing #include lines from input files. This can improve performance and incrementality by decreasing the size of compilation input trees. However, it can also break builds because the include scanner does not fully implement C preprocessor semantics. In particular, it does not understand dynamic #include directives and ignores preprocessor conditional logic. Use at your own risk. Any issues relating to this flag that are filed will be closed. At Google without this flag your build will most likely fail.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--incremental_dexing"><code><a href="#flag--incremental_dexing">--[no]incremental_dexing</a></code> default: "true"</dt>
<dd>
<p>Does most of the work for dexing separately for each Jar file.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--objc_use_dotd_pruning"><code><a href="#flag--objc_use_dotd_pruning">--[no]objc_use_dotd_pruning</a></code> default: "true"</dt>
<dd>
<p>If set, .d files emitted by clang will be used to prune the set of inputs passed into objc compiles.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--process_headers_in_dependencies"><code><a href="#flag--process_headers_in_dependencies">--[no]process_headers_in_dependencies</a></code> default: "false"</dt>
<dd>
<p>When building a target //a:a, process headers in all targets that //a:a depends on (if header processing is enabled for the toolchain).</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--trim_test_configuration"><code><a href="#flag--trim_test_configuration">--[no]trim_test_configuration</a></code> default: "true"</dt>
<dd>
<p>When enabled, test-related options will be cleared below the top level of the build. When this flag is active, tests cannot be built as dependencies of non-test rules, but changes to test-related options will not cause non-test rules to be re-analyzed.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
</dl>
<dl>Options that affect the verbosity, format or location of logging:
<dt id="flag--toolchain_resolution_debug"><code><a href="#flag--toolchain_resolution_debug">--toolchain_resolution_debug</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths&gt;</code> default: "-.*"</dt>
<dd>
<p>Print debug information during toolchain resolution. The flag takes a regex, which is checked against toolchain types and specific targets to see which to debug. Multiple regexes may be  separated by commas, and then each regex is checked separately. Note: The output of this flag is very complex and will likely only be useful to experts in toolchain resolution.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="flag--verbose_visibility_errors"><code><a href="#flag--verbose_visibility_errors">--[no]verbose_visibility_errors</a></code> default: "false"</dt>
<dd>
<p>If enabled, visibility errors include additional diagnostic information.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
</dl>
<dl>Options specifying or altering a generic input to a Bazel command that does not fall into other categories.:
<dt id="flag--flag_alias"><code><a href="#flag--flag_alias">--flag_alias</a>=&lt;a &#39;name=value&#39; flag alias&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Sets a shorthand name for a Starlark flag. It takes a single key-value pair in the form
<code>{key}={value}</code> as an argument.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--incompatible_default_to_explicit_init_py"><code><a href="#flag--incompatible_default_to_explicit_init_py">--[no]incompatible_default_to_explicit_init_py</a></code> default: "false"</dt>
<dd>
<p>This flag changes the default behavior so that <strong>init</strong>.py files are no longer automatically created in the runfiles of Python targets. Precisely, when a py_binary or py_test target has legacy_create_init set to &quot;auto&quot; (the default), it is treated as false if and only if this flag is set. See https://github.com/bazelbuild/bazel/issues/10076.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Miscellaneous options, not otherwise categorized.:
<dt id="flag--cache_test_results"><code><a href="#flag--cache_test_results">--[no]cache_test_results</a></code> [<code>-t</code>] default: "auto"</dt>
<dd>
<p>If set to <code>auto</code>, Bazel reruns a test if and only if:</p>
<ol>
<li>Bazel detects changes in the test or its dependencies,</li>
<li>The test is marked as <code>external</code>,</li>
<li>Multiple test runs were requested with <code>--runs_per_test</code>, or</li>
<li>The test previously failed.
If set to <code>yes</code>, Bazel caches all test results except for tests marked as
<code>external</code>. If set to <code>no</code>, Bazel does not cache any test results.</li>
</ol>
</dd>
<dt id="flag--experimental_cancel_concurrent_tests"><code><a href="#flag--experimental_cancel_concurrent_tests">--[no]experimental_cancel_concurrent_tests</a></code> default: "never"</dt>
<dd>
<p>If <code>on_failed</code> or <code>on_passed</code>, then Blaze will cancel concurrently running tests on the first
successful run with that result. This is only useful in combination with
<code>--runs_per_test_detects_flakes</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_fetch_all_coverage_outputs"><code><a href="#flag--experimental_fetch_all_coverage_outputs">--[no]experimental_fetch_all_coverage_outputs</a></code> default: "false"</dt>
<dd>
<p>If true, then Bazel fetches the entire coverage data directory for each test during a coverage run.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_generate_llvm_lcov"><code><a href="#flag--experimental_generate_llvm_lcov">--[no]experimental_generate_llvm_lcov</a></code> default: "false"</dt>
<dd>
<p>If true, coverage for clang will generate an LCOV report.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_java_classpath"><code><a href="#flag--experimental_java_classpath">--experimental_java_classpath</a>=&lt;off, javabuilder, bazel or bazel_no_fallback&gt;</code> default: "bazel"</dt>
<dd>
<p>Enables reduced classpaths for Java compilations.</p>
</dd>
<dt id="flag--experimental_run_android_lint_on_java_rules"><code><a href="#flag--experimental_run_android_lint_on_java_rules">--[no]experimental_run_android_lint_on_java_rules</a></code> default: "false"</dt>
<dd>
<p>Whether to validate java_* sources.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--explicit_java_test_deps"><code><a href="#flag--explicit_java_test_deps">--[no]explicit_java_test_deps</a></code> default: "false"</dt>
<dd>
<p>Explicitly specify a dependency to JUnit or Hamcrest in a java_test instead of  accidentally obtaining from the TestRunner's deps. Only works for bazel right now.</p>
</dd>
<dt id="flag--host_java_launcher"><code><a href="#flag--host_java_launcher">--host_java_launcher</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The Java launcher used by tools that are executed during a build.</p>
</dd>
<dt id="flag--host_javacopt"><code><a href="#flag--host_javacopt">--host_javacopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to javac when building tools that are executed during a build.</p>
</dd>
<dt id="flag--host_jvmopt"><code><a href="#flag--host_jvmopt">--host_jvmopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the Java VM when building tools that are executed during  the build. These options will get added to the VM startup options of each  java_binary target.</p>
</dd>
<dt id="flag--incompatible_check_sharding_support"><code><a href="#flag--incompatible_check_sharding_support">--[no]incompatible_check_sharding_support</a></code> default: "true"</dt>
<dd>
<p>If true, Bazel will fail a sharded test if the test runner does not indicate that it
supports sharding by touching the file at the path in <code>TEST_SHARD_STATUS_FILE</code>.
If false, a test runner that does not support sharding will lead to all tests
running in each shard.</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_exclusive_test_sandboxed"><code><a href="#flag--incompatible_exclusive_test_sandboxed">--[no]incompatible_exclusive_test_sandboxed</a></code> default: "true"</dt>
<dd>
<p>If true, exclusive tests will run with sandboxed strategy. Add <code>local</code> tag to force
an exclusive test run locally</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_strict_action_env"><code><a href="#flag--incompatible_strict_action_env">--[no]incompatible_strict_action_env</a></code> default: "false"</dt>
<dd>
<p>If true, Bazel uses an environment with a static value for PATH and does not
inherit <code>LD_LIBRARY_PATH</code>. Use <code>--action_env=ENV_VARIABLE</code> if you want to
inherit specific environment variables from the client, but note that doing so
can prevent cross-user caching if a shared cache is used.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--j2objc_translation_flags"><code><a href="#flag--j2objc_translation_flags">--j2objc_translation_flags</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the J2ObjC tool.</p>
</dd>
<dt id="flag--java_debug"><code><a href="#flag--java_debug">--java_debug</a></code></dt>
<dd>
<p>Causes the Java virtual machine of a java test to wait for a connection from a JDWP-compliant debugger (such as jdb) before starting the test. Implies -test_output=streamed.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--test_arg">--test_arg=--wrapper_script_flag=--debug</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--test_output">--test_output=streamed</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--test_strategy">--test_strategy=exclusive</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--test_timeout">--test_timeout=9999</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--nocache_test_results">--nocache_test_results</a></code>
</p></dd>
<dt id="flag--java_deps"><code><a href="#flag--java_deps">--[no]java_deps</a></code> default: "true"</dt>
<dd>
<p>Generate dependency information (for now, compile-time classpath) per Java target.</p>
</dd>
<dt id="flag--java_header_compilation"><code><a href="#flag--java_header_compilation">--[no]java_header_compilation</a></code> default: "true"</dt>
<dd>
<p>Compile ijars directly from source.</p>
</dd>
<dt id="flag--java_language_version"><code><a href="#flag--java_language_version">--java_language_version</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The Java language version</p>
</dd>
<dt id="flag--java_launcher"><code><a href="#flag--java_launcher">--java_launcher</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The Java launcher to use when building Java binaries.  If this flag is set to the empty string, the JDK launcher is used. The &quot;launcher&quot; attribute overrides this flag.</p>
</dd>
<dt id="flag--java_runtime_version"><code><a href="#flag--java_runtime_version">--java_runtime_version</a>=&lt;a string&gt;</code> default: "local_jdk"</dt>
<dd>
<p>The Java runtime version</p>
</dd>
<dt id="flag--javacopt"><code><a href="#flag--javacopt">--javacopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to javac.</p>
</dd>
<dt id="flag--jvmopt"><code><a href="#flag--jvmopt">--jvmopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the Java VM. These options will get added to the VM startup options of each java_binary target.</p>
</dd>
<dt id="flag--legacy_main_dex_list_generator"><code><a href="#flag--legacy_main_dex_list_generator">--legacy_main_dex_list_generator</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies a binary to use to generate the list of classes that must be in the main dex when compiling legacy multidex.</p>
</dd>
<dt id="flag--optimizing_dexer"><code><a href="#flag--optimizing_dexer">--optimizing_dexer</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies a binary to use to do dexing without sharding.</p>
</dd>
<dt id="flag--plugin"><code><a href="#flag--plugin">--plugin</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Plugins to use in the build. Currently works with java_plugin.</p>
</dd>
<dt id="flag--proguard_top"><code><a href="#flag--proguard_top">--proguard_top</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies which version of ProGuard to use for code removal when building a Java binary.</p>
</dd>
<dt id="flag--proto_compiler"><code><a href="#flag--proto_compiler">--proto_compiler</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:protoc"</dt>
<dd>
<p>The label of the proto-compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_profile"><code><a href="#flag--proto_profile">--[no]proto_profile</a></code> default: "true"</dt>
<dd>
<p>Whether to pass profile_path to the proto compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_profile_path"><code><a href="#flag--proto_profile_path">--proto_profile_path</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The profile to pass to the proto compiler as profile_path. If unset, but  --proto_profile is true (the default), infers the path from --fdo_optimize.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_cc"><code><a href="#flag--proto_toolchain_for_cc">--proto_toolchain_for_cc</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:cc_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile C++ protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_j2objc"><code><a href="#flag--proto_toolchain_for_j2objc">--proto_toolchain_for_j2objc</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/j2objc:j2objc_proto_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile j2objc protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_java"><code><a href="#flag--proto_toolchain_for_java">--proto_toolchain_for_java</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:java_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile Java protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_javalite"><code><a href="#flag--proto_toolchain_for_javalite">--proto_toolchain_for_javalite</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:javalite_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile JavaLite protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--protocopt"><code><a href="#flag--protocopt">--protocopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the protobuf compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--runs_per_test_detects_flakes"><code><a href="#flag--runs_per_test_detects_flakes">--[no]runs_per_test_detects_flakes</a></code> default: "false"</dt>
<dd>
<p>If true, any shard in which at least one run/attempt passes and at least one run/attempt fails gets a FLAKY status.</p>
</dd>
<dt id="flag--shell_executable"><code><a href="#flag--shell_executable">--shell_executable</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>Absolute path to the shell executable for Bazel to use. If this is unset, but the
<code>BAZEL_SH</code> environment variable is set on the first Bazel invocation (that starts
up a Bazel server), Bazel uses that. If neither is set, Bazel uses a hard-coded
default path depending on the operating system it runs on;</p>
<ul>
<li>Windows: <code>c:/msys64/usr/bin/bash.exe</code></li>
<li>FreeBSD: <code>/usr/local/bin/bash</code></li>
<li>All others: <code>/bin/bash</code>.</li>
</ul>
<p>Note that using a shell that is not compatible with <code>bash</code> may lead
to build failures or runtime failures of the generated binaries.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--test_arg"><code><a href="#flag--test_arg">--test_arg</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies additional options and arguments that should be passed to the test
executable. Can be used multiple times to specify several arguments.
If multiple tests are executed, each of them will receive identical arguments.
Used only by the <code>bazel test</code> command.</p>
</dd>
<dt id="flag--test_filter"><code><a href="#flag--test_filter">--test_filter</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specifies a filter to forward to the test framework.  Used to limit the tests run. Note that this does not affect which targets are built.</p>
</dd>
<dt id="flag--test_result_expiration"><code><a href="#flag--test_result_expiration">--test_result_expiration</a>=&lt;an integer&gt;</code> default: "-1"</dt>
<dd>
<p>This option is deprecated and has no effect.</p>
</dd>
<dt id="flag--test_runner_fail_fast"><code><a href="#flag--test_runner_fail_fast">--[no]test_runner_fail_fast</a></code> default: "false"</dt>
<dd>
<p>Forwards fail fast option to the test runner. The test runner should stop execution upon first failure.</p>
</dd>
<dt id="flag--test_sharding_strategy"><code><a href="#flag--test_sharding_strategy">--test_sharding_strategy</a>=&lt;explicit, disabled or forced=k where k is the number of shards to enforce&gt;</code> default: "explicit"</dt>
<dd>
<p>Specify strategy for test sharding:</p>
<ul>
<li><code>explicit</code> to only use sharding if the <code>shard_count</code> <code>BUILD</code> attribute is
present.</li>
<li><code>disabled</code> to never use test sharding.</li>
<li><code>forced=k</code> to enforce <code>k</code> shards for testing regardless of the <code>shard_count</code> <code>BUILD</code>
attribute.</li>
</ul>
</dd>
<dt id="flag--tool_java_language_version"><code><a href="#flag--tool_java_language_version">--tool_java_language_version</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The Java language version used to execute the tools that are needed during a build</p>
</dd>
<dt id="flag--tool_java_runtime_version"><code><a href="#flag--tool_java_runtime_version">--tool_java_runtime_version</a>=&lt;a string&gt;</code> default: "remotejdk_11"</dt>
<dd>
<p>The Java runtime version used to execute tools during the build</p>
</dd>
<dt id="flag--use_ijars"><code><a href="#flag--use_ijars">--[no]use_ijars</a></code> default: "true"</dt>
<dd>
<p>If enabled, this option causes Java compilation to use interface jars. This will result in faster incremental compilation, but error messages can be different.</p>
</dd>
</dl>

<h2><a name="help">Help Options</a></h2>
<dl>Options that affect the verbosity, format or location of logging:
<dt id="help-flag--help_verbosity"><code id="help_verbosity"><a href="#help-flag--help_verbosity">--help_verbosity</a>=&lt;long, medium or short&gt;</code> default: "medium"</dt>
<dd>
<p>Select the verbosity of the help command.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="help-flag--long"><code id="long"><a href="#help-flag--long">--long</a></code> [<code>-l</code>]</dt>
<dd>
<p>Show full description of each option, instead of just its name.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--help_verbosity">--help_verbosity=long</a></code>
</p><p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="help-flag--short"><code id="short"><a href="#help-flag--short">--short</a></code></dt>
<dd>
<p>Show only the names of the options, not their types or meanings.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--help_verbosity">--help_verbosity=short</a></code>
</p><p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
</dl>

<h2><a name="info">Info Options</a></h2>
<p>Inherits all options from <a href="#build">build</a>.</p>

<dl>Options that let the user configure the intended output, affecting its value, as opposed to its existence:
<dt id="info-flag--info_output_type"><code id="info_output_type"><a href="#info-flag--info_output_type">--info_output_type</a>=&lt;stdout or response_proto&gt;</code> default: "stdout"</dt>
<dd>
<p>If stdout, results are directly printed to the console. If response_proto, the info command results are packed in response extensions.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
</dl>
<dl>Options that affect the verbosity, format or location of logging:
<dt id="info-flag--show_make_env"><code id="show_make_env"><a href="#info-flag--show_make_env">--[no]show_make_env</a></code> default: "false"</dt>
<dd>
<p>Include the &quot;Make&quot; environment in the output.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
</dl>

<h2><a name="license">License Options</a></h2>

<h2><a name="mobile-install">Mobile-install Options</a></h2>
<p>Inherits all options from <a href="#build">build</a>.</p>

<dl>Options that control build execution:
<dt id="mobile-install-flag--mode"><code id="mode"><a href="#mobile-install-flag--mode">--mode</a>=&lt;classic, classic_internal_test_do_not_use or skylark&gt;</code> default: "skylark"</dt>
<dd>
<p>Deprecated no-effect flag. Only skylark mode is still supported.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options that configure the toolchain used for action execution:
<dt id="mobile-install-flag--adb"><code id="adb"><a href="#mobile-install-flag--adb">--adb</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>adb binary to use for the 'mobile-install' command. If unspecified, the one in the Android SDK specified by the --android_sdk_channel command line option (or  the default SDK if --android_sdk_channel is not specified) is used.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
</dl>
<dl>Options that control the output of the command:
<dt id="mobile-install-flag--incremental"><code id="incremental"><a href="#mobile-install-flag--incremental">--[no]incremental</a></code> default: "false"</dt>
<dd>
<p>Whether to do an incremental install. If true, try to avoid unnecessary additional work by reading the state of the device the code is to be installed on and using that information to avoid unnecessary work. If false (the default), always do a full install.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="mobile-install-flag--split_apks"><code id="split_apks"><a href="#mobile-install-flag--split_apks">--[no]split_apks</a></code> default: "false"</dt>
<dd>
<p>Whether to use split apks to install and update the application on the device. Works only with devices with Marshmallow or later</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
</dl>
<dl>Options that let the user configure the intended output, affecting its value, as opposed to its existence:
<dt id="mobile-install-flag--adb_arg"><code id="adb_arg"><a href="#mobile-install-flag--adb_arg">--adb_arg</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Extra arguments to pass to adb. Usually used to designate a device to install to.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="mobile-install-flag--debug_app"><code id="debug_app"><a href="#mobile-install-flag--debug_app">--debug_app</a></code></dt>
<dd>
<p>Whether to wait for the debugger before starting the app.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--start">--start=DEBUG</a></code>
</p><p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="mobile-install-flag--device"><code id="device"><a href="#mobile-install-flag--device">--device</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The adb device serial number. If not specified, the first device will be used.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="mobile-install-flag--start"><code id="start"><a href="#mobile-install-flag--start">--start</a>=&lt;no, cold, warm or debug&gt;</code> default: "NO"</dt>
<dd>
<p>How the app should be started after installing it. Set to WARM to preserve and restore application state on incremental installs.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="mobile-install-flag--start_app"><code id="start_app"><a href="#mobile-install-flag--start_app">--start_app</a></code></dt>
<dd>
<p>Whether to start the app after installing it.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--start">--start=COLD</a></code>
</p><p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
</dl>
<dl>Options that affect the verbosity, format or location of logging:
<dt id="mobile-install-flag--incremental_install_verbosity"><code id="incremental_install_verbosity"><a href="#mobile-install-flag--incremental_install_verbosity">--incremental_install_verbosity</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The verbosity for incremental install. Set to 1 for debug logging.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></a>
</p></dd>
</dl>

<h2><a name="mod">Mod Options</a></h2>
<dl>Options that control build execution:
<dt id="mod-flag--experimental_remotable_source_manifests"><code id="experimental_remotable_source_manifests"><a href="#mod-flag--experimental_remotable_source_manifests">--[no]experimental_remotable_source_manifests</a></code> default: "false"</dt>
<dd>
<p>Whether to make source manifest actions remotable</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="mod-flag--experimental_strict_fileset_output"><code id="experimental_strict_fileset_output"><a href="#mod-flag--experimental_strict_fileset_output">--[no]experimental_strict_fileset_output</a></code> default: "false"</dt>
<dd>
<p>If this option is enabled, filesets will treat all output artifacts as regular files. They will not traverse directories or be sensitive to symlinks.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="mod-flag--incompatible_modify_execution_info_additive"><code id="incompatible_modify_execution_info_additive"><a href="#mod-flag--incompatible_modify_execution_info_additive">--[no]incompatible_modify_execution_info_additive</a></code> default: "true"</dt>
<dd>
<p>When enabled, passing multiple <code>--modify_execution_info</code> flags is additive.
When disabled, only the last flag is taken into account.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="mod-flag--loading_phase_threads"><code id="loading_phase_threads"><a href="#mod-flag--loading_phase_threads">--loading_phase_threads</a>=&lt;an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|*]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS*.5&quot;&gt;</code> default: "auto"</dt>
<dd>
<p>Number of parallel threads to use for the loading/analysis phase.Takes an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|<em>]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS</em>.5&quot;. &quot;auto&quot; sets a reasonable default based on host resources. Must be at least 1.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="mod-flag--modify_execution_info"><code id="modify_execution_info"><a href="#mod-flag--modify_execution_info">--modify_execution_info</a>=&lt;regex=[+-]key,regex=[+-]key,...&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Add or remove keys from an action's execution info based on action mnemonic.
Applies only to actions which support execution info. Many common actions
support execution info, e.g. Genrule, CppCompile, Javac, StarlarkAction,
TestRunner. When specifying multiple values, order matters because
many regexes may apply to the same mnemonic.</p>
<p>Syntax: <code>regex=[+-]key,regex=[+-]key,...</code>.</p>
<p>Examples:</p>
<ul>
<li><code>.*=+x,.*=-y,.*=+z</code> adds <code>x</code> and <code>z</code> to, and removes <code>y</code> from, the execution info for all actions.</li>
<li><code>Genrule=+requires-x</code> adds <code>requires-x</code> to the execution info for all Genrule actions.</li>
<li><code>(?!Genrule).*=-requires-x</code> removes <code>requires-x</code> from the execution info for all non-Genrule actions.</li>
</ul>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="mod-flag--use_target_platform_for_tests"><code id="use_target_platform_for_tests"><a href="#mod-flag--use_target_platform_for_tests">--[no]use_target_platform_for_tests</a></code> default: "false"</dt>
<dd>
<p>If true, use the target platform for running tests rather than the test exec group.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
</dl>
<dl>Options that configure the toolchain used for action execution:
<dt id="mod-flag--incompatible_bazel_test_exec_run_under"><code id="incompatible_bazel_test_exec_run_under"><a href="#mod-flag--incompatible_bazel_test_exec_run_under">--[no]incompatible_bazel_test_exec_run_under</a></code> default: "true"</dt>
<dd>
<p>If enabled, <code>bazel test --run_under=//:runner</code> builds <code>//:runner</code> in the exec
configuration. If disabled, it builds <code>//:runner</code> in the target configuration.
Bazel executes tests on exec machines, so the former is more correct. This
doesn't affect <code>bazel run</code>, which always builds <code>--run_under=//foo</code> in the
target configuration.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options that control the output of the command:
<dt id="mod-flag--build_runfile_links"><code id="build_runfile_links"><a href="#mod-flag--build_runfile_links">--[no]build_runfile_links</a></code> default: "true"</dt>
<dd>
<p>If true, build runfiles symlink forests for all targets.  If false, write them only when required by a local action, test or run command.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="mod-flag--build_runfile_manifests"><code id="build_runfile_manifests"><a href="#mod-flag--build_runfile_manifests">--[no]build_runfile_manifests</a></code> default: "true"</dt>
<dd>
<p>If true, write runfiles manifests for all targets. If false, omit them. Local tests will fail to run when false.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="mod-flag--incompatible_always_include_files_in_data"><code id="incompatible_always_include_files_in_data"><a href="#mod-flag--incompatible_always_include_files_in_data">--[no]incompatible_always_include_files_in_data</a></code> default: "true"</dt>
<dd>
<p>If true, native rules add <code>DefaultInfo.files</code> of data dependencies to their runfiles,
which matches the recommended behavior for Starlark rules (<a href="https://bazel.build/extending/rules#runfiles_features_to_avoid">runfiles features to avoid</a>).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="mod-flag--incompatible_compact_repo_mapping_manifest"><code id="incompatible_compact_repo_mapping_manifest"><a href="#mod-flag--incompatible_compact_repo_mapping_manifest">--[no]incompatible_compact_repo_mapping_manifest</a></code> default: "false"</dt>
<dd>
<p>If enabled, the <code>{binary}.repo_mapping</code> file emits a module extension's repo mapping
only once instead of once for each repo generated by the extension that
contributes runfiles.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="mod-flag--incompatible_disable_select_on"><code id="incompatible_disable_select_on"><a href="#mod-flag--incompatible_disable_select_on">--incompatible_disable_select_on</a>=&lt;comma-separated set of options&gt;</code> default: ""</dt>
<dd>
<p>List of flags for which the use in <code>select()</code> is disabled.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="mod-flag--incompatible_filegroup_runfiles_for_data"><code id="incompatible_filegroup_runfiles_for_data"><a href="#mod-flag--incompatible_filegroup_runfiles_for_data">--[no]incompatible_filegroup_runfiles_for_data</a></code> default: "true"</dt>
<dd>
<p>If true, runfiles of targets listed in the srcs attribute are available to targets that consume the filegroup as a data dependency.</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options that let the user configure the intended output, affecting its value, as opposed to its existence:
<dt id="mod-flag--action_env"><code id="action_env"><a href="#mod-flag--action_env">--action_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the set of environment variables available to actions with target
configuration. Variables can be either specified by <code>name</code>, in which case
the value will be taken from the invocation environment, by the <code>name=value</code>
pair which sets the value independent of the invocation environment, or by
<code>=name</code>, which unsets the variable of that name. This option can be used
multiple times; for options given for the same variable, the latest wins,
options for different variables accumulate.</p>
<p>Note that unless <code>--incompatible_repo_env_ignores_action_env</code> is true, all <code>name=value</code>
pairs will be available to repository rules.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="mod-flag--allowed_cpu_values"><code id="allowed_cpu_values"><a href="#mod-flag--allowed_cpu_values">--allowed_cpu_values</a>=&lt;comma-separated set of options&gt;</code> default: ""</dt>
<dd>
<p>Allowed values for the <code>--cpu</code> flag.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="mod-flag--collect_code_coverage"><code id="collect_code_coverage"><a href="#mod-flag--collect_code_coverage">--[no]collect_code_coverage</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will instrument code (using offline instrumentation where
possible) and will collect coverage information during tests. Only targets that
match <code>--instrumentation_filter</code> will be affected. Usually this option should
not be specified directly - <code>bazel coverage</code> command should be used instead.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="mod-flag--compilation_mode"><code id="compilation_mode"><a href="#mod-flag--compilation_mode">--compilation_mode</a>=&lt;fastbuild, dbg or opt&gt;</code> [<code>-c</code>] default: "fastbuild"</dt>
<dd>
<p>Specify the mode the binary will be built in. Values: <code>fastbuild</code>, <code>dbg</code>, <code>opt</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="mod-flag--cpu"><code id="cpu"><a href="#mod-flag--cpu">--cpu</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Deprecated: this flag is not used internally by Blaze although there are legacy platform
mappings to allow for backwards compatibility. Do not use this flag, instead use
<code>--platforms</code> with an appropriate platform definition.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="mod-flag--define"><code id="define"><a href="#mod-flag--define">--define</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Each <code>--define</code> option specifies an assignment for a build variable.
In case of multiple values for a variable, the last one wins.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="mod-flag--enable_runfiles"><code id="enable_runfiles"><a href="#mod-flag--enable_runfiles">--[no]enable_runfiles</a></code> default: "auto"</dt>
<dd>
<p>Enable runfiles symlink tree; By default, it's off on Windows, on on other platforms.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="mod-flag--exec_aspects"><code id="exec_aspects"><a href="#mod-flag--exec_aspects">--exec_aspects</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of aspects to be applied to exec-configured targets, regardless of whether or not they are top-level targets. This is an experimental feature and is subject to change.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="mod-flag--experimental_action_listener"><code id="experimental_action_listener"><a href="#mod-flag--experimental_action_listener">--experimental_action_listener</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Deprecated in favor of aspects. Use <code>action_listener</code> to attach an <code>extra_action</code> to
existing build actions.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="mod-flag--experimental_collect_code_coverage_for_generated_files"><code id="experimental_collect_code_coverage_for_generated_files"><a href="#mod-flag--experimental_collect_code_coverage_for_generated_files">--[no]experimental_collect_code_coverage_for_generated_files</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will also generate collect coverage information for generated files.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="mod-flag--experimental_output_paths"><code id="experimental_output_paths"><a href="#mod-flag--experimental_output_paths">--experimental_output_paths</a>=&lt;off or strip&gt;</code> default: "off"</dt>
<dd>
<p>Which model to use for where in the output tree rules write their outputs, particularly
for multi-platform / multi-configuration builds. This is highly experimental. See
<a href="https://github.com/bazelbuild/bazel/issues/6526">GH-6526</a> for details. Starlark actions can opt into path mapping by adding the key
<code>supports-path-mapping</code> to the <code>execution_requirements</code> dict.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="mod-flag--experimental_override_platform_cpu_name"><code id="experimental_override_platform_cpu_name"><a href="#mod-flag--experimental_override_platform_cpu_name">--experimental_override_platform_cpu_name</a>=&lt;a &#39;label=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Each entry should be of the form <code>label=value</code> where label refers to a platform and values
is the desired shortname to override the platform's CPU name in <code>$(TARGET_CPU)</code>
make variable and output path. Only used when
<code>--experimental_platform_in_output_dir</code>, <code>--incompatible_target_cpu_from_platform</code> or
<code>--incompatible_bep_cpu_from_platform</code> is true. Has highest naming priority.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="mod-flag--experimental_platform_in_output_dir"><code id="experimental_platform_in_output_dir"><a href="#mod-flag--experimental_platform_in_output_dir">--[no]experimental_platform_in_output_dir</a></code> default: "Auto"</dt>
<dd>
<p>If true, a shortname for the target platform is used in the output directory name
instead of the CPU. The exact scheme is experimental and subject to change:</p>
<ol>
<li>First, in the rare case the <code>--platforms</code> option does not have exactly one value, a
hash of the platforms option is used.</li>
<li>Next, if any shortname for the current platform was registered by
<code>--experimental_override_name_platform_in_output_dir</code>, then that shortname is used.</li>
<li>Then, if <code>--experimental_use_platforms_in_output_dir_legacy_heuristic</code> is set, use a
shortname based off the current platform Label.</li>
<li>Finally, a hash of the platform option is used as a last resort.</li>
</ol>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="mod-flag--experimental_use_platforms_in_output_dir_legacy_heuristic"><code id="experimental_use_platforms_in_output_dir_legacy_heuristic"><a href="#mod-flag--experimental_use_platforms_in_output_dir_legacy_heuristic">--[no]experimental_use_platforms_in_output_dir_legacy_heuristic</a></code> default: "true"</dt>
<dd>
<p>Please only use this flag as part of a suggested migration or testing strategy. Note
that the heuristic has known deficiencies and it is suggested to migrate to
relying on just <code>--experimental_override_name_platform_in_output_dir</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="mod-flag--features"><code id="features"><a href="#mod-flag--features">--features</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The given features will be enabled or disabled by default for targets built in the target configuration.
Specifying <code>-{feature}</code> will disable the feature. Negative features always override positive ones.
See also <code>--host_features</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="mod-flag--host_action_env"><code id="host_action_env"><a href="#mod-flag--host_action_env">--host_action_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the set of environment variables available to actions with execution
configurations. Variables can be either specified by <code>name</code>, in which case the
value will be taken from the invocation environment, by the <code>name=value</code> pair
which sets the value independent of the invocation environment, or by
<code>=name</code>, which unsets the variable of that name. This option can
be used multiple times; for options given for the same variable, the latest
wins, options for different variables accumulate.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="mod-flag--host_compilation_mode"><code id="host_compilation_mode"><a href="#mod-flag--host_compilation_mode">--host_compilation_mode</a>=&lt;fastbuild, dbg or opt&gt;</code> default: "opt"</dt>
<dd>
<p>Specify the mode the tools used during the build will be built in. Values:
<code>fastbuild</code>, <code>dbg</code>, <code>opt</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="mod-flag--host_cpu"><code id="host_cpu"><a href="#mod-flag--host_cpu">--host_cpu</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The host CPU.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="mod-flag--host_features"><code id="host_features"><a href="#mod-flag--host_features">--host_features</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The given features will be enabled or disabled by default for targets built in the exec configuration.
Specifying <code>-{feature}</code> will disable the feature. Negative features always override positive ones.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="mod-flag--incompatible_auto_exec_groups"><code id="incompatible_auto_exec_groups"><a href="#mod-flag--incompatible_auto_exec_groups">--[no]incompatible_auto_exec_groups</a></code> default: "false"</dt>
<dd>
<p>When enabled, an exec groups is automatically created for each toolchain used by a rule.
For this to work rule needs to specify <code>toolchain</code> parameter on its actions. For
more information, see <a href="https://github.com/bazelbuild/bazel/issues/17134">GH-17134</a>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="mod-flag--incompatible_merge_genfiles_directory"><code id="incompatible_merge_genfiles_directory"><a href="#mod-flag--incompatible_merge_genfiles_directory">--[no]incompatible_merge_genfiles_directory</a></code> default: "true"</dt>
<dd>
<p>If true, the genfiles directory is folded into the bin directory.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="mod-flag--incompatible_target_cpu_from_platform"><code id="incompatible_target_cpu_from_platform"><a href="#mod-flag--incompatible_target_cpu_from_platform">--[no]incompatible_target_cpu_from_platform</a></code> default: "true"</dt>
<dd>
<p>If specified, the value of the cpu constraint (<code>@platforms//cpu:cpu</code>) of
the target platform is used to set the <code>$(TARGET_CPU)</code> make variable.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="mod-flag--instrument_test_targets"><code id="instrument_test_targets"><a href="#mod-flag--instrument_test_targets">--[no]instrument_test_targets</a></code> default: "false"</dt>
<dd>
<p>When coverage is enabled, specifies whether to consider instrumenting test rules.
When set, test rules included by <code>--instrumentation_filter</code> are instrumented.
Otherwise, test rules are always excluded from coverage instrumentation.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="mod-flag--instrumentation_filter"><code id="instrumentation_filter"><a href="#mod-flag--instrumentation_filter">--instrumentation_filter</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths&gt;</code> default: "-/javatests[/:],-/test/java[/:]"</dt>
<dd>
<p>When coverage is enabled, only rules with names included by the
specified regex-based filter will be instrumented. Rules prefixed
with '-' are excluded instead. Note that only non-test rules are
instrumented unless <code>--instrument_test_targets</code> is enabled.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="mod-flag--platform_suffix"><code id="platform_suffix"><a href="#mod-flag--platform_suffix">--platform_suffix</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specifies a suffix to be added to the configuration directory.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="mod-flag--run_under"><code id="run_under"><a href="#mod-flag--run_under">--run_under</a>=&lt;a prefix in front of command&gt;</code> default: see description</dt>
<dd>
<p>Prefix to insert before the executables for the <code>test</code> and <code>run</code> commands.
If the value is <code>foo -bar</code>, and the execution command line is <code>test_binary -baz</code>,
then the final command line is <code>foo -bar test_binary -baz</code>.
This can also be a label to an executable target. Some examples are:</p>
<ul>
<li><code>valgrind</code></li>
<li><code>strace</code></li>
<li><code>strace -c</code></li>
<li><code>valgrind --quiet --num-callers=20</code></li>
<li><code>//package:target</code></li>
<li><code>//package:target --options</code></li>
</ul>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="mod-flag--stamp"><code id="stamp"><a href="#mod-flag--stamp">--[no]stamp</a></code> default: "false"</dt>
<dd>
<p>Stamp binaries with the date, username, hostname, workspace information, etc.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
</dl>
<dl>Options that affect how strictly Bazel enforces valid build inputs (rule definitions,  flag combinations, etc.):
<dt id="mod-flag--check_visibility"><code id="check_visibility"><a href="#mod-flag--check_visibility">--[no]check_visibility</a></code> default: "true"</dt>
<dd>
<p>If disabled, visibility errors in target dependencies are demoted to warnings.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="mod-flag--enforce_constraints"><code id="enforce_constraints"><a href="#mod-flag--enforce_constraints">--[no]enforce_constraints</a></code> default: "true"</dt>
<dd>
<p>Checks the environments each target is compatible with and reports errors if any target has dependencies that don't support the same environments</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="mod-flag--experimental_enforce_transitive_visibility"><code id="experimental_enforce_transitive_visibility"><a href="#mod-flag--experimental_enforce_transitive_visibility">--[no]experimental_enforce_transitive_visibility</a></code> default: "false"</dt>
<dd>
<p>If true, enable package()s to set the transitive_visibility attribute to restrict which packages may depend on them.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="mod-flag--incompatible_check_testonly_for_output_files"><code id="incompatible_check_testonly_for_output_files"><a href="#mod-flag--incompatible_check_testonly_for_output_files">--[no]incompatible_check_testonly_for_output_files</a></code> default: "false"</dt>
<dd>
<p>If enabled, check testonly for prerequisite targets that are output files by looking up the testonly of the generating rule. This matches visibility checking.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="mod-flag--strict_filesets"><code id="strict_filesets"><a href="#mod-flag--strict_filesets">--[no]strict_filesets</a></code> default: "false"</dt>
<dd>
<p>If this option is enabled, filesets crossing package boundaries are reported as errors.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="mod-flag--target_environment"><code id="target_environment"><a href="#mod-flag--target_environment">--target_environment</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Declares this build's target environment. Must be a label reference to an
<a href="https://github.com/bazelbuild/bazel/blob/master/src/main/java/com/google/devtools/build/lib/analysis/constraints/EnvironmentRule.java"><code>environment</code> rule</a>. If specified, all top-level targets must be compatible with this
environment.</p>
<p>See also <code>--platforms</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
</dl>
<dl>This option affects semantics of the Starlark language or the build API accessible to BUILD files, .bzl files, or WORKSPACE files.:
<dt id="mod-flag--incompatible_config_setting_private_default_visibility"><code id="incompatible_config_setting_private_default_visibility"><a href="#mod-flag--incompatible_config_setting_private_default_visibility">--[no]incompatible_config_setting_private_default_visibility</a></code> default: "false"</dt>
<dd>
<p>If incompatible_enforce_config_setting_visibility=false, this is a noop. Else, if this flag is false, any config_setting without an explicit visibility attribute is //visibility:public. If this flag is true, config_setting follows the same visibility logic as all other rules. See https://github.com/bazelbuild/bazel/issues/12933.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="mod-flag--incompatible_enforce_config_setting_visibility"><code id="incompatible_enforce_config_setting_visibility"><a href="#mod-flag--incompatible_enforce_config_setting_visibility">--[no]incompatible_enforce_config_setting_visibility</a></code> default: "true"</dt>
<dd>
<p>If true, enforce config_setting visibility restrictions. If false, every config_setting is visible to every target. See https://github.com/bazelbuild/bazel/issues/12932.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options that govern the behavior of the test environment or test runner:
<dt id="mod-flag--allow_analysis_failures"><code id="allow_analysis_failures"><a href="#mod-flag--allow_analysis_failures">--[no]allow_analysis_failures</a></code> default: "false"</dt>
<dd>
<p>If true, an analysis failure of a rule target results in the target's propagation
of an instance of <code>AnalysisFailureInfo</code> containing the error description, instead
of resulting in a build failure.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="mod-flag--analysis_testing_deps_limit"><code id="analysis_testing_deps_limit"><a href="#mod-flag--analysis_testing_deps_limit">--analysis_testing_deps_limit</a>=&lt;an integer&gt;</code> default: "2000"</dt>
<dd>
<p>Sets the maximum number of transitive dependencies through a rule attribute with
a <code>for_analysis_testing</code> configuration transition.
Exceeding this limit will result in a rule error.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
</dl>
<dl>Options relating to the output and semantics of the `mod` subcommand:
<dt id="mod-flag--base_module"><code id="base_module"><a href="#mod-flag--base_module">--base_module</a>=&lt;&quot;&lt;root&gt;&quot; for the root module; &lt;module&gt;@&lt;version&gt; for a specific version of a module; &lt;module&gt; for all versions of a module; @&lt;name&gt; for a repo with the given apparent name; or @@&lt;name&gt; for a repo with the given canonical name&gt;</code> default: "&lt;root&gt;"</dt>
<dd>
<p>Specify a module relative to which the specified target repos will be interpreted.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="mod-flag--charset"><code id="charset"><a href="#mod-flag--charset">--charset</a>=&lt;utf8 or ascii&gt;</code> default: "utf8"</dt>
<dd>
<p>Chooses the character set to use for the tree. Only affects text output. Valid values
are <code>utf8</code> or <code>ascii</code>. Default is <code>utf8</code></p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="mod-flag--cycles"><code id="cycles"><a href="#mod-flag--cycles">--[no]cycles</a></code> default: "true"</dt>
<dd>
<p>Points out dependency cycles inside the displayed tree.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="mod-flag--depth"><code id="depth"><a href="#mod-flag--depth">--depth</a>=&lt;an integer&gt;</code> default: "-1"</dt>
<dd>
<p>Maximum display depth of the dependency tree. A depth of 1 displays the direct
dependencies, for example. For <code>tree</code>, <code>path</code> and <code>all_paths</code> it defaults to
<code>Integer.MAX_VALUE</code>, while for <code>deps</code> and <code>explain</code> it defaults to 1 (only displays
direct deps of the root besides the target leaves and their parents).</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="mod-flag--extension_filter"><code id="extension_filter"><a href="#mod-flag--extension_filter">--extension_filter</a>=&lt;a comma-separated list of &lt;extension&gt;s&gt;</code> default: see description</dt>
<dd>
<p>Only display the usages of these module extensions and the repos generated by them if their respective flags are set. If set, the result graph will only include paths that contain modules using the specified extensions. An empty list disables the filter, effectively specifying all possible extensions.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="mod-flag--extension_info"><code id="extension_info"><a href="#mod-flag--extension_info">--extension_info</a>=&lt;hidden, usages, repos or all&gt;</code> default: "hidden"</dt>
<dd>
<p>Specify how much detail about extension usages to include in the query result.</p>
<ul>
<li><code>hidden</code> will not show any extension information.</li>
<li><code>usages</code> will only show the extensions names.</li>
<li><code>repos</code> will also include repos imported with <code>use_repo</code>.</li>
<li><code>all</code> will also show the other repositories generated by extensions.</li>
</ul>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="mod-flag--extension_usages"><code id="extension_usages"><a href="#mod-flag--extension_usages">--extension_usages</a>=&lt;a comma-separated list of &lt;module&gt;s&gt;</code> default: ""</dt>
<dd>
<p>Specify modules whose extension usages will be displayed in the show_extension query.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="mod-flag--from"><code id="from"><a href="#mod-flag--from">--from</a>=&lt;a comma-separated list of &lt;module&gt;s&gt;</code> default: "&lt;root&gt;"</dt>
<dd>
<p>The module(s) starting from which the dependency graph query will be displayed. Check
each query’s description for the exact semantics. Defaults to <code>&amp;lt;root&amp;gt;</code>.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="mod-flag--include_builtin"><code id="include_builtin"><a href="#mod-flag--include_builtin">--[no]include_builtin</a></code> default: "false"</dt>
<dd>
<p>Include built-in modules in the dependency graph. Disabled by default because it is quite noisy.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="mod-flag--include_unused"><code id="include_unused"><a href="#mod-flag--include_unused">--[no]include_unused</a></code> default: "false"</dt>
<dd>
<p>The queries will also take into account and display the unused modules, which are not
present in the module resolution graph after selection (due to the
Minimal-Version Selection or override rules). This can have different effects for
each of the query types i.e. include new paths in the <code>all_paths</code> command, or extra
dependants in the <code>explain</code> command.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="mod-flag--output"><code id="output"><a href="#mod-flag--output">--output</a>=&lt;text, json or graph&gt;</code> default: "text"</dt>
<dd>
<p>The format in which the query results should be printed. Allowed values for query are:
<code>text</code>, <code>json</code>, <code>graph</code>.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="mod-flag--verbose"><code id="verbose"><a href="#mod-flag--verbose">--[no]verbose</a></code> default: "false"</dt>
<dd>
<p>The queries will also display the reason why modules were resolved to their current version (if changed). Defaults to true only for the explain query.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
</dl>
<dl>Options that affect the verbosity, format or location of logging:
<dt id="mod-flag--verbose_visibility_errors"><code id="verbose_visibility_errors"><a href="#mod-flag--verbose_visibility_errors">--[no]verbose_visibility_errors</a></code> default: "false"</dt>
<dd>
<p>If enabled, visibility errors include additional diagnostic information.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
</dl>
<dl>Options specifying or altering a generic input to a Bazel command that does not fall into other categories.:
<dt id="mod-flag--flag_alias"><code id="flag_alias"><a href="#mod-flag--flag_alias">--flag_alias</a>=&lt;a &#39;name=value&#39; flag alias&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Sets a shorthand name for a Starlark flag. It takes a single key-value pair in the form
<code>{key}={value}</code> as an argument.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
</dl>
<dl>Miscellaneous options, not otherwise categorized.:
<dt id="mod-flag--deleted_packages"><code id="deleted_packages"><a href="#mod-flag--deleted_packages">--deleted_packages</a>=&lt;comma-separated list of package names&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>A comma-separated list of names of packages which the build system will consider non-existent, even if they are visible somewhere on the package path.
Use this option when deleting a subpackage 'x/y' of an existing package 'x'.  For example, after deleting x/y/BUILD in your client, the build system may complain if it encounters a label '//x:y/z' if that is still provided by another package_path entry.  Specifying --deleted_packages x/y avoids this problem.</p>
</dd>
<dt id="mod-flag--fetch"><code id="fetch"><a href="#mod-flag--fetch">--[no]fetch</a></code> default: "true"</dt>
<dd>
<p>Allows the command to fetch external dependencies. If set to false, the command will utilize any cached version of the dependency, and if none exists, the command will result in failure.</p>
</dd>
<dt id="mod-flag--package_path"><code id="package_path"><a href="#mod-flag--package_path">--package_path</a>=&lt;colon-separated list of options&gt;</code> default: "%workspace%"</dt>
<dd>
<p>A colon-separated list of where to look for packages. Elements beginning with '%workspace%' are relative to the enclosing workspace. If omitted or empty, the default is the output of 'bazel info default-package-path'.</p>
</dd>
<dt id="mod-flag--show_loading_progress"><code id="show_loading_progress"><a href="#mod-flag--show_loading_progress">--[no]show_loading_progress</a></code> default: "true"</dt>
<dd>
<p>If enabled, causes Bazel to print &quot;Loading package:&quot; messages.</p>
</dd>
</dl>

<h2><a name="print_action">Print_action Options</a></h2>
<p>Inherits all options from <a href="#build">build</a>.</p>

<dl>Miscellaneous options, not otherwise categorized.:
<dt id="print_action-flag--print_action_mnemonics"><code id="print_action_mnemonics"><a href="#print_action-flag--print_action_mnemonics">--print_action_mnemonics</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Lists which mnemonics to filter print_action data by, no filtering takes place when left empty.</p>
</dd>
</dl>

<h2><a name="query">Query Options</a></h2>
<dl>Options that control build execution:
<dt id="query-flag--experimental_remotable_source_manifests"><code id="experimental_remotable_source_manifests"><a href="#query-flag--experimental_remotable_source_manifests">--[no]experimental_remotable_source_manifests</a></code> default: "false"</dt>
<dd>
<p>Whether to make source manifest actions remotable</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="query-flag--experimental_strict_fileset_output"><code id="experimental_strict_fileset_output"><a href="#query-flag--experimental_strict_fileset_output">--[no]experimental_strict_fileset_output</a></code> default: "false"</dt>
<dd>
<p>If this option is enabled, filesets will treat all output artifacts as regular files. They will not traverse directories or be sensitive to symlinks.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="query-flag--incompatible_modify_execution_info_additive"><code id="incompatible_modify_execution_info_additive"><a href="#query-flag--incompatible_modify_execution_info_additive">--[no]incompatible_modify_execution_info_additive</a></code> default: "true"</dt>
<dd>
<p>When enabled, passing multiple <code>--modify_execution_info</code> flags is additive.
When disabled, only the last flag is taken into account.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="query-flag--keep_going"><code id="keep_going"><a href="#query-flag--keep_going">--[no]keep_going</a></code> [<code>-k</code>] default: "false"</dt>
<dd>
<p>Continue as much as possible after an error.  While the target that failed and those that depend on it cannot be analyzed, other prerequisites of these targets can be.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="query-flag--loading_phase_threads"><code id="loading_phase_threads"><a href="#query-flag--loading_phase_threads">--loading_phase_threads</a>=&lt;an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|*]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS*.5&quot;&gt;</code> default: "auto"</dt>
<dd>
<p>Number of parallel threads to use for the loading/analysis phase.Takes an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|<em>]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS</em>.5&quot;. &quot;auto&quot; sets a reasonable default based on host resources. Must be at least 1.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
<dt id="query-flag--modify_execution_info"><code id="modify_execution_info"><a href="#query-flag--modify_execution_info">--modify_execution_info</a>=&lt;regex=[+-]key,regex=[+-]key,...&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Add or remove keys from an action's execution info based on action mnemonic.
Applies only to actions which support execution info. Many common actions
support execution info, e.g. Genrule, CppCompile, Javac, StarlarkAction,
TestRunner. When specifying multiple values, order matters because
many regexes may apply to the same mnemonic.</p>
<p>Syntax: <code>regex=[+-]key,regex=[+-]key,...</code>.</p>
<p>Examples:</p>
<ul>
<li><code>.*=+x,.*=-y,.*=+z</code> adds <code>x</code> and <code>z</code> to, and removes <code>y</code> from, the execution info for all actions.</li>
<li><code>Genrule=+requires-x</code> adds <code>requires-x</code> to the execution info for all Genrule actions.</li>
<li><code>(?!Genrule).*=-requires-x</code> removes <code>requires-x</code> from the execution info for all non-Genrule actions.</li>
</ul>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="query-flag--use_target_platform_for_tests"><code id="use_target_platform_for_tests"><a href="#query-flag--use_target_platform_for_tests">--[no]use_target_platform_for_tests</a></code> default: "false"</dt>
<dd>
<p>If true, use the target platform for running tests rather than the test exec group.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
</dl>
<dl>Options that configure the toolchain used for action execution:
<dt id="query-flag--incompatible_bazel_test_exec_run_under"><code id="incompatible_bazel_test_exec_run_under"><a href="#query-flag--incompatible_bazel_test_exec_run_under">--[no]incompatible_bazel_test_exec_run_under</a></code> default: "true"</dt>
<dd>
<p>If enabled, <code>bazel test --run_under=//:runner</code> builds <code>//:runner</code> in the exec
configuration. If disabled, it builds <code>//:runner</code> in the target configuration.
Bazel executes tests on exec machines, so the former is more correct. This
doesn't affect <code>bazel run</code>, which always builds <code>--run_under=//foo</code> in the
target configuration.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options that control the output of the command:
<dt id="query-flag--build_runfile_links"><code id="build_runfile_links"><a href="#query-flag--build_runfile_links">--[no]build_runfile_links</a></code> default: "true"</dt>
<dd>
<p>If true, build runfiles symlink forests for all targets.  If false, write them only when required by a local action, test or run command.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="query-flag--build_runfile_manifests"><code id="build_runfile_manifests"><a href="#query-flag--build_runfile_manifests">--[no]build_runfile_manifests</a></code> default: "true"</dt>
<dd>
<p>If true, write runfiles manifests for all targets. If false, omit them. Local tests will fail to run when false.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="query-flag--incompatible_always_include_files_in_data"><code id="incompatible_always_include_files_in_data"><a href="#query-flag--incompatible_always_include_files_in_data">--[no]incompatible_always_include_files_in_data</a></code> default: "true"</dt>
<dd>
<p>If true, native rules add <code>DefaultInfo.files</code> of data dependencies to their runfiles,
which matches the recommended behavior for Starlark rules (<a href="https://bazel.build/extending/rules#runfiles_features_to_avoid">runfiles features to avoid</a>).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="query-flag--incompatible_compact_repo_mapping_manifest"><code id="incompatible_compact_repo_mapping_manifest"><a href="#query-flag--incompatible_compact_repo_mapping_manifest">--[no]incompatible_compact_repo_mapping_manifest</a></code> default: "false"</dt>
<dd>
<p>If enabled, the <code>{binary}.repo_mapping</code> file emits a module extension's repo mapping
only once instead of once for each repo generated by the extension that
contributes runfiles.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="query-flag--incompatible_disable_select_on"><code id="incompatible_disable_select_on"><a href="#query-flag--incompatible_disable_select_on">--incompatible_disable_select_on</a>=&lt;comma-separated set of options&gt;</code> default: ""</dt>
<dd>
<p>List of flags for which the use in <code>select()</code> is disabled.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="query-flag--incompatible_filegroup_runfiles_for_data"><code id="incompatible_filegroup_runfiles_for_data"><a href="#query-flag--incompatible_filegroup_runfiles_for_data">--[no]incompatible_filegroup_runfiles_for_data</a></code> default: "true"</dt>
<dd>
<p>If true, runfiles of targets listed in the srcs attribute are available to targets that consume the filegroup as a data dependency.</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options that let the user configure the intended output, affecting its value, as opposed to its existence:
<dt id="query-flag--action_env"><code id="action_env"><a href="#query-flag--action_env">--action_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the set of environment variables available to actions with target
configuration. Variables can be either specified by <code>name</code>, in which case
the value will be taken from the invocation environment, by the <code>name=value</code>
pair which sets the value independent of the invocation environment, or by
<code>=name</code>, which unsets the variable of that name. This option can be used
multiple times; for options given for the same variable, the latest wins,
options for different variables accumulate.</p>
<p>Note that unless <code>--incompatible_repo_env_ignores_action_env</code> is true, all <code>name=value</code>
pairs will be available to repository rules.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="query-flag--allowed_cpu_values"><code id="allowed_cpu_values"><a href="#query-flag--allowed_cpu_values">--allowed_cpu_values</a>=&lt;comma-separated set of options&gt;</code> default: ""</dt>
<dd>
<p>Allowed values for the <code>--cpu</code> flag.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="query-flag--collect_code_coverage"><code id="collect_code_coverage"><a href="#query-flag--collect_code_coverage">--[no]collect_code_coverage</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will instrument code (using offline instrumentation where
possible) and will collect coverage information during tests. Only targets that
match <code>--instrumentation_filter</code> will be affected. Usually this option should
not be specified directly - <code>bazel coverage</code> command should be used instead.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="query-flag--compilation_mode"><code id="compilation_mode"><a href="#query-flag--compilation_mode">--compilation_mode</a>=&lt;fastbuild, dbg or opt&gt;</code> [<code>-c</code>] default: "fastbuild"</dt>
<dd>
<p>Specify the mode the binary will be built in. Values: <code>fastbuild</code>, <code>dbg</code>, <code>opt</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="query-flag--cpu"><code id="cpu"><a href="#query-flag--cpu">--cpu</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Deprecated: this flag is not used internally by Blaze although there are legacy platform
mappings to allow for backwards compatibility. Do not use this flag, instead use
<code>--platforms</code> with an appropriate platform definition.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="query-flag--define"><code id="define"><a href="#query-flag--define">--define</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Each <code>--define</code> option specifies an assignment for a build variable.
In case of multiple values for a variable, the last one wins.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="query-flag--enable_runfiles"><code id="enable_runfiles"><a href="#query-flag--enable_runfiles">--[no]enable_runfiles</a></code> default: "auto"</dt>
<dd>
<p>Enable runfiles symlink tree; By default, it's off on Windows, on on other platforms.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="query-flag--exec_aspects"><code id="exec_aspects"><a href="#query-flag--exec_aspects">--exec_aspects</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of aspects to be applied to exec-configured targets, regardless of whether or not they are top-level targets. This is an experimental feature and is subject to change.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="query-flag--experimental_action_listener"><code id="experimental_action_listener"><a href="#query-flag--experimental_action_listener">--experimental_action_listener</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Deprecated in favor of aspects. Use <code>action_listener</code> to attach an <code>extra_action</code> to
existing build actions.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="query-flag--experimental_collect_code_coverage_for_generated_files"><code id="experimental_collect_code_coverage_for_generated_files"><a href="#query-flag--experimental_collect_code_coverage_for_generated_files">--[no]experimental_collect_code_coverage_for_generated_files</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will also generate collect coverage information for generated files.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="query-flag--experimental_output_paths"><code id="experimental_output_paths"><a href="#query-flag--experimental_output_paths">--experimental_output_paths</a>=&lt;off or strip&gt;</code> default: "off"</dt>
<dd>
<p>Which model to use for where in the output tree rules write their outputs, particularly
for multi-platform / multi-configuration builds. This is highly experimental. See
<a href="https://github.com/bazelbuild/bazel/issues/6526">GH-6526</a> for details. Starlark actions can opt into path mapping by adding the key
<code>supports-path-mapping</code> to the <code>execution_requirements</code> dict.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="query-flag--experimental_override_platform_cpu_name"><code id="experimental_override_platform_cpu_name"><a href="#query-flag--experimental_override_platform_cpu_name">--experimental_override_platform_cpu_name</a>=&lt;a &#39;label=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Each entry should be of the form <code>label=value</code> where label refers to a platform and values
is the desired shortname to override the platform's CPU name in <code>$(TARGET_CPU)</code>
make variable and output path. Only used when
<code>--experimental_platform_in_output_dir</code>, <code>--incompatible_target_cpu_from_platform</code> or
<code>--incompatible_bep_cpu_from_platform</code> is true. Has highest naming priority.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="query-flag--experimental_platform_in_output_dir"><code id="experimental_platform_in_output_dir"><a href="#query-flag--experimental_platform_in_output_dir">--[no]experimental_platform_in_output_dir</a></code> default: "Auto"</dt>
<dd>
<p>If true, a shortname for the target platform is used in the output directory name
instead of the CPU. The exact scheme is experimental and subject to change:</p>
<ol>
<li>First, in the rare case the <code>--platforms</code> option does not have exactly one value, a
hash of the platforms option is used.</li>
<li>Next, if any shortname for the current platform was registered by
<code>--experimental_override_name_platform_in_output_dir</code>, then that shortname is used.</li>
<li>Then, if <code>--experimental_use_platforms_in_output_dir_legacy_heuristic</code> is set, use a
shortname based off the current platform Label.</li>
<li>Finally, a hash of the platform option is used as a last resort.</li>
</ol>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="query-flag--experimental_use_platforms_in_output_dir_legacy_heuristic"><code id="experimental_use_platforms_in_output_dir_legacy_heuristic"><a href="#query-flag--experimental_use_platforms_in_output_dir_legacy_heuristic">--[no]experimental_use_platforms_in_output_dir_legacy_heuristic</a></code> default: "true"</dt>
<dd>
<p>Please only use this flag as part of a suggested migration or testing strategy. Note
that the heuristic has known deficiencies and it is suggested to migrate to
relying on just <code>--experimental_override_name_platform_in_output_dir</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="query-flag--features"><code id="features"><a href="#query-flag--features">--features</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The given features will be enabled or disabled by default for targets built in the target configuration.
Specifying <code>-{feature}</code> will disable the feature. Negative features always override positive ones.
See also <code>--host_features</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="query-flag--host_action_env"><code id="host_action_env"><a href="#query-flag--host_action_env">--host_action_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the set of environment variables available to actions with execution
configurations. Variables can be either specified by <code>name</code>, in which case the
value will be taken from the invocation environment, by the <code>name=value</code> pair
which sets the value independent of the invocation environment, or by
<code>=name</code>, which unsets the variable of that name. This option can
be used multiple times; for options given for the same variable, the latest
wins, options for different variables accumulate.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="query-flag--host_compilation_mode"><code id="host_compilation_mode"><a href="#query-flag--host_compilation_mode">--host_compilation_mode</a>=&lt;fastbuild, dbg or opt&gt;</code> default: "opt"</dt>
<dd>
<p>Specify the mode the tools used during the build will be built in. Values:
<code>fastbuild</code>, <code>dbg</code>, <code>opt</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="query-flag--host_cpu"><code id="host_cpu"><a href="#query-flag--host_cpu">--host_cpu</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The host CPU.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="query-flag--host_features"><code id="host_features"><a href="#query-flag--host_features">--host_features</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The given features will be enabled or disabled by default for targets built in the exec configuration.
Specifying <code>-{feature}</code> will disable the feature. Negative features always override positive ones.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="query-flag--incompatible_auto_exec_groups"><code id="incompatible_auto_exec_groups"><a href="#query-flag--incompatible_auto_exec_groups">--[no]incompatible_auto_exec_groups</a></code> default: "false"</dt>
<dd>
<p>When enabled, an exec groups is automatically created for each toolchain used by a rule.
For this to work rule needs to specify <code>toolchain</code> parameter on its actions. For
more information, see <a href="https://github.com/bazelbuild/bazel/issues/17134">GH-17134</a>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="query-flag--incompatible_merge_genfiles_directory"><code id="incompatible_merge_genfiles_directory"><a href="#query-flag--incompatible_merge_genfiles_directory">--[no]incompatible_merge_genfiles_directory</a></code> default: "true"</dt>
<dd>
<p>If true, the genfiles directory is folded into the bin directory.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="query-flag--incompatible_target_cpu_from_platform"><code id="incompatible_target_cpu_from_platform"><a href="#query-flag--incompatible_target_cpu_from_platform">--[no]incompatible_target_cpu_from_platform</a></code> default: "true"</dt>
<dd>
<p>If specified, the value of the cpu constraint (<code>@platforms//cpu:cpu</code>) of
the target platform is used to set the <code>$(TARGET_CPU)</code> make variable.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="query-flag--instrument_test_targets"><code id="instrument_test_targets"><a href="#query-flag--instrument_test_targets">--[no]instrument_test_targets</a></code> default: "false"</dt>
<dd>
<p>When coverage is enabled, specifies whether to consider instrumenting test rules.
When set, test rules included by <code>--instrumentation_filter</code> are instrumented.
Otherwise, test rules are always excluded from coverage instrumentation.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="query-flag--instrumentation_filter"><code id="instrumentation_filter"><a href="#query-flag--instrumentation_filter">--instrumentation_filter</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths&gt;</code> default: "-/javatests[/:],-/test/java[/:]"</dt>
<dd>
<p>When coverage is enabled, only rules with names included by the
specified regex-based filter will be instrumented. Rules prefixed
with '-' are excluded instead. Note that only non-test rules are
instrumented unless <code>--instrument_test_targets</code> is enabled.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="query-flag--platform_suffix"><code id="platform_suffix"><a href="#query-flag--platform_suffix">--platform_suffix</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specifies a suffix to be added to the configuration directory.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="query-flag--run_under"><code id="run_under"><a href="#query-flag--run_under">--run_under</a>=&lt;a prefix in front of command&gt;</code> default: see description</dt>
<dd>
<p>Prefix to insert before the executables for the <code>test</code> and <code>run</code> commands.
If the value is <code>foo -bar</code>, and the execution command line is <code>test_binary -baz</code>,
then the final command line is <code>foo -bar test_binary -baz</code>.
This can also be a label to an executable target. Some examples are:</p>
<ul>
<li><code>valgrind</code></li>
<li><code>strace</code></li>
<li><code>strace -c</code></li>
<li><code>valgrind --quiet --num-callers=20</code></li>
<li><code>//package:target</code></li>
<li><code>//package:target --options</code></li>
</ul>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="query-flag--stamp"><code id="stamp"><a href="#query-flag--stamp">--[no]stamp</a></code> default: "false"</dt>
<dd>
<p>Stamp binaries with the date, username, hostname, workspace information, etc.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
</dl>
<dl>Options that affect how strictly Bazel enforces valid build inputs (rule definitions,  flag combinations, etc.):
<dt id="query-flag--check_visibility"><code id="check_visibility"><a href="#query-flag--check_visibility">--[no]check_visibility</a></code> default: "true"</dt>
<dd>
<p>If disabled, visibility errors in target dependencies are demoted to warnings.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="query-flag--enforce_constraints"><code id="enforce_constraints"><a href="#query-flag--enforce_constraints">--[no]enforce_constraints</a></code> default: "true"</dt>
<dd>
<p>Checks the environments each target is compatible with and reports errors if any target has dependencies that don't support the same environments</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="query-flag--experimental_enforce_transitive_visibility"><code id="experimental_enforce_transitive_visibility"><a href="#query-flag--experimental_enforce_transitive_visibility">--[no]experimental_enforce_transitive_visibility</a></code> default: "false"</dt>
<dd>
<p>If true, enable package()s to set the transitive_visibility attribute to restrict which packages may depend on them.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="query-flag--incompatible_check_testonly_for_output_files"><code id="incompatible_check_testonly_for_output_files"><a href="#query-flag--incompatible_check_testonly_for_output_files">--[no]incompatible_check_testonly_for_output_files</a></code> default: "false"</dt>
<dd>
<p>If enabled, check testonly for prerequisite targets that are output files by looking up the testonly of the generating rule. This matches visibility checking.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="query-flag--strict_filesets"><code id="strict_filesets"><a href="#query-flag--strict_filesets">--[no]strict_filesets</a></code> default: "false"</dt>
<dd>
<p>If this option is enabled, filesets crossing package boundaries are reported as errors.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="query-flag--target_environment"><code id="target_environment"><a href="#query-flag--target_environment">--target_environment</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Declares this build's target environment. Must be a label reference to an
<a href="https://github.com/bazelbuild/bazel/blob/master/src/main/java/com/google/devtools/build/lib/analysis/constraints/EnvironmentRule.java"><code>environment</code> rule</a>. If specified, all top-level targets must be compatible with this
environment.</p>
<p>See also <code>--platforms</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
</dl>
<dl>This option affects semantics of the Starlark language or the build API accessible to BUILD files, .bzl files, or WORKSPACE files.:
<dt id="query-flag--incompatible_config_setting_private_default_visibility"><code id="incompatible_config_setting_private_default_visibility"><a href="#query-flag--incompatible_config_setting_private_default_visibility">--[no]incompatible_config_setting_private_default_visibility</a></code> default: "false"</dt>
<dd>
<p>If incompatible_enforce_config_setting_visibility=false, this is a noop. Else, if this flag is false, any config_setting without an explicit visibility attribute is //visibility:public. If this flag is true, config_setting follows the same visibility logic as all other rules. See https://github.com/bazelbuild/bazel/issues/12933.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="query-flag--incompatible_enforce_config_setting_visibility"><code id="incompatible_enforce_config_setting_visibility"><a href="#query-flag--incompatible_enforce_config_setting_visibility">--[no]incompatible_enforce_config_setting_visibility</a></code> default: "true"</dt>
<dd>
<p>If true, enforce config_setting visibility restrictions. If false, every config_setting is visible to every target. See https://github.com/bazelbuild/bazel/issues/12932.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options that govern the behavior of the test environment or test runner:
<dt id="query-flag--allow_analysis_failures"><code id="allow_analysis_failures"><a href="#query-flag--allow_analysis_failures">--[no]allow_analysis_failures</a></code> default: "false"</dt>
<dd>
<p>If true, an analysis failure of a rule target results in the target's propagation
of an instance of <code>AnalysisFailureInfo</code> containing the error description, instead
of resulting in a build failure.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="query-flag--analysis_testing_deps_limit"><code id="analysis_testing_deps_limit"><a href="#query-flag--analysis_testing_deps_limit">--analysis_testing_deps_limit</a>=&lt;an integer&gt;</code> default: "2000"</dt>
<dd>
<p>Sets the maximum number of transitive dependencies through a rule attribute with
a <code>for_analysis_testing</code> configuration transition.
Exceeding this limit will result in a rule error.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
</dl>
<dl>Options relating to query output and semantics:
<dt id="query-flag--aspect_deps"><code id="aspect_deps"><a href="#query-flag--aspect_deps">--aspect_deps</a>=&lt;off, conservative or precise&gt;</code> default: "conservative"</dt>
<dd>
<p>How to resolve aspect dependencies when the output format is one of {xml,proto,record}. 'off' means no aspect dependencies are resolved, 'conservative' (the default) means all declared aspect dependencies are added regardless of whether they are given the rule class of direct dependencies, 'precise' means that only those aspects are added that are possibly active given the rule class of the direct dependencies. Note that precise mode requires loading other packages to evaluate a single target thus making it slower than the other modes. Also note that even precise mode is not completely precise: the decision whether to compute an aspect is decided in the analysis phase, which is not run during 'bazel query'.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="query-flag--consistent_labels"><code id="consistent_labels"><a href="#query-flag--consistent_labels">--[no]consistent_labels</a></code> default: "false"</dt>
<dd>
<p>If enabled, every query command emits labels as if by the Starlark &lt;code&gt;str&lt;/code&gt; function applied to a &lt;code&gt;Label&lt;/code&gt; instance. This is useful for tools that need to match the output of different query commands and/or labels emitted by rules. If not enabled, output formatters are free to emit apparent repository names (relative to the main repository) instead to make the output more readable.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--experimental_explicit_aspects"><code id="experimental_explicit_aspects"><a href="#query-flag--experimental_explicit_aspects">--[no]experimental_explicit_aspects</a></code> default: "false"</dt>
<dd>
<p>aquery, cquery: whether to include aspect-generated actions in the output. query: no-op (aspects are always followed).</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--experimental_graphless_query"><code id="experimental_graphless_query"><a href="#query-flag--experimental_graphless_query">--[no]experimental_graphless_query</a></code> default: "auto"</dt>
<dd>
<p>If true, uses a Query implementation that does not make a copy of the graph. The new implementation only supports --order_output=no, as well as only a subset of output formatters.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="query-flag--graph:conditional_edges_limit"><code id="graph:conditional_edges_limit"><a href="#query-flag--graph:conditional_edges_limit">--graph:conditional_edges_limit</a>=&lt;an integer&gt;</code> default: "4"</dt>
<dd>
<p>The maximum number of condition labels to show. -1 means no truncation and 0 means no annotation. This option is only applicable to --output=graph.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--graph:factored"><code id="graph:factored"><a href="#query-flag--graph:factored">--[no]graph:factored</a></code> default: "true"</dt>
<dd>
<p>If true, then the graph will be emitted 'factored', i.e. topologically-equivalent nodes will be merged together and their labels concatenated. This option is only applicable to --output=graph.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--graph:node_limit"><code id="graph:node_limit"><a href="#query-flag--graph:node_limit">--graph:node_limit</a>=&lt;an integer&gt;</code> default: "512"</dt>
<dd>
<p>The maximum length of the label string for a graph node in the output.  Longer labels will be truncated; -1 means no truncation.  This option is only applicable to --output=graph.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--implicit_deps"><code id="implicit_deps"><a href="#query-flag--implicit_deps">--[no]implicit_deps</a></code> default: "true"</dt>
<dd>
<p>If enabled, implicit dependencies will be included in the dependency graph over which the query operates. An implicit dependency is one that is not explicitly specified in the BUILD file but added by bazel. For cquery, this option controls filtering resolved toolchains.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="query-flag--include_aspects"><code id="include_aspects"><a href="#query-flag--include_aspects">--[no]include_aspects</a></code> default: "true"</dt>
<dd>
<p>aquery, cquery: whether to include aspect-generated actions in the output. query: no-op (aspects are always followed).</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--incompatible_lexicographical_output"><code id="incompatible_lexicographical_output"><a href="#query-flag--incompatible_lexicographical_output">--[no]incompatible_lexicographical_output</a></code> default: "true"</dt>
<dd>
<p>If this option is set, sorts --order_output=auto output in lexicographical order.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="query-flag--incompatible_package_group_includes_double_slash"><code id="incompatible_package_group_includes_double_slash"><a href="#query-flag--incompatible_package_group_includes_double_slash">--[no]incompatible_package_group_includes_double_slash</a></code> default: "true"</dt>
<dd>
<p>If enabled, when outputting package_group's <code>packages</code> attribute, the leading <code>//</code> will not be omitted.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="query-flag--infer_universe_scope"><code id="infer_universe_scope"><a href="#query-flag--infer_universe_scope">--[no]infer_universe_scope</a></code> default: "false"</dt>
<dd>
<p>If set and --universe_scope is unset, then a value of --universe_scope will be inferred as the list of unique target patterns in the query expression. Note that the --universe_scope value inferred for a query expression that uses universe-scoped functions (e.g.<code>allrdeps</code>) may not be what you want, so you should use this option only if you know what you are doing. See https://bazel.build/reference/query#sky-query for details and examples. If --universe_scope is set, then this option's value is ignored. Note: this option applies only to <code>query</code> (i.e. not <code>cquery</code>).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="query-flag--line_terminator_null"><code id="line_terminator_null"><a href="#query-flag--line_terminator_null">--[no]line_terminator_null</a></code> default: "false"</dt>
<dd>
<p>Whether each format is terminated with \0 instead of newline.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--nodep_deps"><code id="nodep_deps"><a href="#query-flag--nodep_deps">--[no]nodep_deps</a></code> default: "true"</dt>
<dd>
<p>If enabled, deps from &quot;nodep&quot; attributes will be included in the dependency graph over which the query operates. A common example of a &quot;nodep&quot; attribute is &quot;visibility&quot;. Run and parse the output of <code>info build-language</code> to learn about all the &quot;nodep&quot; attributes in the build language.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="query-flag--noorder_results"><code id="noorder_results"><a href="#query-flag--noorder_results">--noorder_results</a></code></dt>
<dd>
<p>Output the results in dependency-ordered (default) or unordered fashion. The unordered output is faster but only supported when --output is not minrank, maxrank, or graph.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--order_output">--order_output=no</a></code>
</p><p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--null"><code id="null"><a href="#query-flag--null">--null</a></code></dt>
<dd>
<p>Whether each format is terminated with \0 instead of newline.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--line_terminator_null">--line_terminator_null=true</a></code>
</p><p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--order_output"><code id="order_output"><a href="#query-flag--order_output">--order_output</a>=&lt;no, deps, auto or full&gt;</code> default: "auto"</dt>
<dd>
<p>Output the results unordered (no), dependency-ordered (deps), or fully ordered (full). The default is 'auto', meaning that results are output either dependency-ordered or fully ordered, depending on the output formatter (dependency-ordered for proto, minrank, maxrank, and graph, fully ordered for all others). When output is fully ordered, nodes are printed in a fully deterministic (total) order. First, all nodes are sorted alphabetically. Then, each node in the list is used as the start of a post-order depth-first search in which outgoing edges to unvisited nodes are traversed in alphabetical order of the successor nodes. Finally, nodes are printed in the reverse of the order in which they were visited.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--order_results"><code id="order_results"><a href="#query-flag--order_results">--order_results</a></code></dt>
<dd>
<p>Output the results in dependency-ordered (default) or unordered fashion. The unordered output is faster but only supported when --output is not minrank, maxrank, or graph.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--order_output">--order_output=auto</a></code>
</p><p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--output"><code id="output"><a href="#query-flag--output">--output</a>=&lt;a string&gt;</code> default: "label"</dt>
<dd>
<p>The format in which the query results should be printed. Allowed values for query are: build, graph, streamed_jsonproto, label, label_kind, location, maxrank, minrank, package, proto, streamed_proto, xml.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--output_file"><code id="output_file"><a href="#query-flag--output_file">--output_file</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>When specified, query results will be written directly to this file, and nothing will be printed to Bazel's standard output stream (stdout). In benchmarks, this is generally faster than &lt;code&gt;bazel query &amp;gt; file&lt;/code&gt;.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--proto:default_values"><code id="proto:default_values"><a href="#query-flag--proto:default_values">--[no]proto:default_values</a></code> default: "true"</dt>
<dd>
<p>If true, attributes whose value is not explicitly specified in the BUILD file are included; otherwise they are omitted. This option is applicable to --output=proto</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--proto:definition_stack"><code id="proto:definition_stack"><a href="#query-flag--proto:definition_stack">--[no]proto:definition_stack</a></code> default: "false"</dt>
<dd>
<p>Populate the definition_stack proto field, which records for each rule instance the Starlark call stack at the moment the rule's class was defined.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--proto:flatten_selects"><code id="proto:flatten_selects"><a href="#query-flag--proto:flatten_selects">--[no]proto:flatten_selects</a></code> default: "true"</dt>
<dd>
<p>If enabled, configurable attributes created by select() are flattened. For list types the flattened representation is a list containing each value of the select map exactly once. Scalar types are flattened to null.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="query-flag--proto:include_attribute_source_aspects"><code id="proto:include_attribute_source_aspects"><a href="#query-flag--proto:include_attribute_source_aspects">--[no]proto:include_attribute_source_aspects</a></code> default: "false"</dt>
<dd>
<p>Populate the source_aspect_name proto field of each Attribute with the source aspect that the attribute came from (empty string if it did not).</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--proto:include_starlark_rule_env"><code id="proto:include_starlark_rule_env"><a href="#query-flag--proto:include_starlark_rule_env">--[no]proto:include_starlark_rule_env</a></code> default: "true"</dt>
<dd>
<p>Use the starlark environment in the value of the generated $internal_attr_hash attribute. This ensures that the starlark rule definition (and its transitive imports) are part of this identifier.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--proto:include_synthetic_attribute_hash"><code id="proto:include_synthetic_attribute_hash"><a href="#query-flag--proto:include_synthetic_attribute_hash">--[no]proto:include_synthetic_attribute_hash</a></code> default: "false"</dt>
<dd>
<p>Whether or not to calculate and populate the $internal_attr_hash attribute.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--proto:instantiation_stack"><code id="proto:instantiation_stack"><a href="#query-flag--proto:instantiation_stack">--[no]proto:instantiation_stack</a></code> default: "false"</dt>
<dd>
<p>Populate the instantiation call stack of each rule. Note that this requires the stack to be present</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--proto:locations"><code id="proto:locations"><a href="#query-flag--proto:locations">--[no]proto:locations</a></code> default: "true"</dt>
<dd>
<p>Whether to output location information in proto output at all.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--proto:output_rule_attrs"><code id="proto:output_rule_attrs"><a href="#query-flag--proto:output_rule_attrs">--proto:output_rule_attrs</a>=&lt;comma-separated list of options&gt;</code> default: "all"</dt>
<dd>
<p>Comma separated list of attributes to include in output. Defaults to all attributes. Set to empty string to not output any attribute. This option is applicable to --output=proto.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--proto:rule_classes"><code id="proto:rule_classes"><a href="#query-flag--proto:rule_classes">--[no]proto:rule_classes</a></code> default: "false"</dt>
<dd>
<p>Populate the rule_class_key field of each rule; and for the first rule with a given rule_class_key, also populate its rule_class_info proto field. The rule_class_key field uniquely identifies a rule class, and the rule_class_info field is a Stardoc-format rule class API definition.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--proto:rule_inputs_and_outputs"><code id="proto:rule_inputs_and_outputs"><a href="#query-flag--proto:rule_inputs_and_outputs">--[no]proto:rule_inputs_and_outputs</a></code> default: "true"</dt>
<dd>
<p>Whether or not to populate the rule_input and rule_output fields.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--query_file"><code id="query_file"><a href="#query-flag--query_file">--query_file</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>If set, query will read the query from the file named here, rather than on the command line. It is an error to specify a file here as well as a command-line query.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="query-flag--relative_locations"><code id="relative_locations"><a href="#query-flag--relative_locations">--[no]relative_locations</a></code> default: "false"</dt>
<dd>
<p>If true, the location of BUILD files in xml and proto outputs will be relative. By default, the location output is an absolute path and will not be consistent across machines. You can set this option to true to have a consistent result across machines.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--strict_test_suite"><code id="strict_test_suite"><a href="#query-flag--strict_test_suite">--[no]strict_test_suite</a></code> default: "false"</dt>
<dd>
<p>If true, the tests() expression gives an error if it encounters a test_suite containing non-test targets.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="query-flag--tool_deps"><code id="tool_deps"><a href="#query-flag--tool_deps">--[no]tool_deps</a></code> default: "true"</dt>
<dd>
<p>Query: If disabled, dependencies on 'exec configuration' will not be included in the dependency graph over which the query operates. An 'exec configuration' dependency edge, such as the one from any 'proto_library' rule to the Protocol Compiler, usually points to a tool executed during the build rather than a part of the same 'target' program.
Cquery: If disabled, filters out all configured targets which cross an execution transition from the top-level target that discovered this configured target. That means if the top-level target is in the target configuration, only configured targets also in the target configuration will be returned. If the top-level target is in the exec configuration, only exec configured targets will be returned. This option will NOT exclude resolved toolchains.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="query-flag--universe_scope"><code id="universe_scope"><a href="#query-flag--universe_scope">--universe_scope</a>=&lt;comma-separated list of options&gt;</code> default: ""</dt>
<dd>
<p>A comma-separated set of target patterns (additive and subtractive). The query may be performed in the universe defined by the transitive closure of the specified targets. This option is used for the query and cquery commands.
For cquery, the input to this option is the targets all answers are built under and so this option may affect configurations and transitions. If this option is not specified, the top-level targets are assumed to be the targets parsed from the query expression. Note: For cquery, not specifying this option may cause the build to break if targets parsed from the query expression are not buildable with top-level options.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="query-flag--xml:default_values"><code id="xml:default_values"><a href="#query-flag--xml:default_values">--[no]xml:default_values</a></code> default: "false"</dt>
<dd>
<p>If true, rule attributes whose value is not explicitly specified in the BUILD file are printed; otherwise they are omitted.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="query-flag--xml:line_numbers"><code id="xml:line_numbers"><a href="#query-flag--xml:line_numbers">--[no]xml:line_numbers</a></code> default: "true"</dt>
<dd>
<p>If true, XML output contains line numbers. Disabling this option may make diffs easier to read.  This option is only applicable to --output=xml.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
</dl>
<dl>Options that affect the verbosity, format or location of logging:
<dt id="query-flag--verbose_visibility_errors"><code id="verbose_visibility_errors"><a href="#query-flag--verbose_visibility_errors">--[no]verbose_visibility_errors</a></code> default: "false"</dt>
<dd>
<p>If enabled, visibility errors include additional diagnostic information.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
</dl>
<dl>Options specifying or altering a generic input to a Bazel command that does not fall into other categories.:
<dt id="query-flag--flag_alias"><code id="flag_alias"><a href="#query-flag--flag_alias">--flag_alias</a>=&lt;a &#39;name=value&#39; flag alias&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Sets a shorthand name for a Starlark flag. It takes a single key-value pair in the form
<code>{key}={value}</code> as an argument.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
</dl>
<dl>Miscellaneous options, not otherwise categorized.:
<dt id="query-flag--deleted_packages"><code id="deleted_packages"><a href="#query-flag--deleted_packages">--deleted_packages</a>=&lt;comma-separated list of package names&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>A comma-separated list of names of packages which the build system will consider non-existent, even if they are visible somewhere on the package path.
Use this option when deleting a subpackage 'x/y' of an existing package 'x'.  For example, after deleting x/y/BUILD in your client, the build system may complain if it encounters a label '//x:y/z' if that is still provided by another package_path entry.  Specifying --deleted_packages x/y avoids this problem.</p>
</dd>
<dt id="query-flag--fetch"><code id="fetch"><a href="#query-flag--fetch">--[no]fetch</a></code> default: "true"</dt>
<dd>
<p>Allows the command to fetch external dependencies. If set to false, the command will utilize any cached version of the dependency, and if none exists, the command will result in failure.</p>
</dd>
<dt id="query-flag--package_path"><code id="package_path"><a href="#query-flag--package_path">--package_path</a>=&lt;colon-separated list of options&gt;</code> default: "%workspace%"</dt>
<dd>
<p>A colon-separated list of where to look for packages. Elements beginning with '%workspace%' are relative to the enclosing workspace. If omitted or empty, the default is the output of 'bazel info default-package-path'.</p>
</dd>
<dt id="query-flag--show_loading_progress"><code id="show_loading_progress"><a href="#query-flag--show_loading_progress">--[no]show_loading_progress</a></code> default: "true"</dt>
<dd>
<p>If enabled, causes Bazel to print &quot;Loading package:&quot; messages.</p>
</dd>
</dl>

<h2><a name="run">Run Options</a></h2>
<p>Inherits all options from <a href="#build">build</a>.</p>

<dl>Options that appear before the command and are parsed by the client:
<dt id="run-flag--portable_paths"><code id="portable_paths"><a href="#run-flag--portable_paths">--[no]portable_paths</a></code> default: "false"</dt>
<dd>
<p>If true, includes paths to replace in ExecRequest to make the resulting paths portable.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="run-flag--run"><code id="run"><a href="#run-flag--run">--[no]run</a></code> default: "true"</dt>
<dd>
<p>If false, skip running the command line constructed for the built target. Note that this flag is ignored for all --script_path builds.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="run-flag--run_env"><code id="run_env"><a href="#run-flag--run_env">--run_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the set of environment variables available to the target to run. Variables can be either specified by name, in which case the value will be taken from the invocation environment, by the &lt;code&gt;name=value&lt;/code&gt; pair which sets the value independent of the invocation environment, or by &lt;code&gt;=name&lt;/code&gt;, which unsets the variable of that name. This option can be used multiple times; for options given for the same variable, the latest wins, options for different variables accumulate. Note that the executed target will generally see the full environment of the host except for those variables that have been explicitly unset.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="run-flag--run_in_cwd"><code id="run_in_cwd"><a href="#run-flag--run_in_cwd">--[no]run_in_cwd</a></code> default: "false"</dt>
<dd>
<p>If true, runs the target in the current working directory instead of the runfile tree.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
</dl>
<dl>Options that let the user configure the intended output, affecting its value, as opposed to its existence:
<dt id="run-flag--script_path"><code id="script_path"><a href="#run-flag--script_path">--script_path</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>If set, write a shell script to the given file which invokes the target. If this option is set, the target is not run from bazel. Use 'bazel run --script_path=foo //foo &amp;&amp; ./foo' to invoke target '//foo' This differs from 'bazel run //foo' in that the bazel lock is released and the executable is connected to the terminal's stdin.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
</dl>

<h2><a name="shutdown">Shutdown Options</a></h2>
<dl>Options that control the output of the command:
<dt id="shutdown-flag--iff_heap_size_greater_than"><code id="iff_heap_size_greater_than"><a href="#shutdown-flag--iff_heap_size_greater_than">--iff_heap_size_greater_than</a>=&lt;an integer&gt;</code> default: "0"</dt>
<dd>
<p>Iff non-zero, then shutdown will only shut down the server if the total memory (in MB) consumed by the JVM exceeds this value.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
</dl>

<h2><a name="test">Test Options</a></h2>
<p>Inherits all options from <a href="#build">build</a>.</p>

<dl>Options that affect the verbosity, format or location of logging:
<dt id="test-flag--print_relative_test_log_paths"><code id="print_relative_test_log_paths"><a href="#test-flag--print_relative_test_log_paths">--[no]print_relative_test_log_paths</a></code> default: "false"</dt>
<dd>
<p>If true, when printing the path to a test log, use relative path that makes use of the 'testlogs' convenience symlink. N.B. - A subsequent 'build'/'test'/etc invocation with a different configuration can cause the target of this symlink to change, making the path printed previously no longer useful.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="test-flag--test_verbose_timeout_warnings"><code id="test_verbose_timeout_warnings"><a href="#test-flag--test_verbose_timeout_warnings">--[no]test_verbose_timeout_warnings</a></code> default: "false"</dt>
<dd>
<p>If true, print additional warnings when the actual test execution time does not match the timeout defined by the test (whether implied or explicit).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="test-flag--verbose_test_summary"><code id="verbose_test_summary"><a href="#test-flag--verbose_test_summary">--[no]verbose_test_summary</a></code> default: "true"</dt>
<dd>
<p>If true, print additional information (timing, number of failed runs, etc) in the test summary.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
</dl>

<h2><a name="vendor">Vendor Options</a></h2>
<p>Inherits all options from <a href="#test">test</a>.</p>

<dl>Options that control build execution:
<dt id="vendor-flag--keep_going"><code id="keep_going"><a href="#vendor-flag--keep_going">--[no]keep_going</a></code> [<code>-k</code>] default: "false"</dt>
<dd>
<p>Continue as much as possible after an error.  While the target that failed and those that depend on it cannot be analyzed, other prerequisites of these targets can be.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="vendor-flag--loading_phase_threads"><code id="loading_phase_threads"><a href="#vendor-flag--loading_phase_threads">--loading_phase_threads</a>=&lt;an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|*]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS*.5&quot;&gt;</code> default: "auto"</dt>
<dd>
<p>Number of parallel threads to use for the loading/analysis phase.Takes an integer, or a keyword (&quot;auto&quot;, &quot;HOST_CPUS&quot;, &quot;HOST_RAM&quot;), optionally followed by an operation ([-|<em>]&lt;float&gt;) eg. &quot;auto&quot;, &quot;HOST_CPUS</em>.5&quot;. &quot;auto&quot; sets a reasonable default based on host resources. Must be at least 1.</p>
<p>Tags:
<a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>
</p></dd>
</dl>
<dl>This option affects semantics of the Starlark language or the build API accessible to BUILD files, .bzl files, or WORKSPACE files.:
<dt id="vendor-flag--incompatible_config_setting_private_default_visibility"><code id="incompatible_config_setting_private_default_visibility"><a href="#vendor-flag--incompatible_config_setting_private_default_visibility">--[no]incompatible_config_setting_private_default_visibility</a></code> default: "false"</dt>
<dd>
<p>If incompatible_enforce_config_setting_visibility=false, this is a noop. Else, if this flag is false, any config_setting without an explicit visibility attribute is //visibility:public. If this flag is true, config_setting follows the same visibility logic as all other rules. See https://github.com/bazelbuild/bazel/issues/12933.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="vendor-flag--incompatible_enforce_config_setting_visibility"><code id="incompatible_enforce_config_setting_visibility"><a href="#vendor-flag--incompatible_enforce_config_setting_visibility">--[no]incompatible_enforce_config_setting_visibility</a></code> default: "true"</dt>
<dd>
<p>If true, enforce config_setting visibility restrictions. If false, every config_setting is visible to every target. See https://github.com/bazelbuild/bazel/issues/12932.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options relating to Bzlmod output and semantics:
<dt id="vendor-flag--repo"><code id="repo"><a href="#vendor-flag--repo">--repo</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Only vendors the specified repository, which can be either <code>@apparent_repo_name</code> or
<code>@@canonical_repo_name</code>. This option can be set multiple times.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
</dl>
<dl>Miscellaneous options, not otherwise categorized.:
<dt id="vendor-flag--deleted_packages"><code id="deleted_packages"><a href="#vendor-flag--deleted_packages">--deleted_packages</a>=&lt;comma-separated list of package names&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>A comma-separated list of names of packages which the build system will consider non-existent, even if they are visible somewhere on the package path.
Use this option when deleting a subpackage 'x/y' of an existing package 'x'.  For example, after deleting x/y/BUILD in your client, the build system may complain if it encounters a label '//x:y/z' if that is still provided by another package_path entry.  Specifying --deleted_packages x/y avoids this problem.</p>
</dd>
<dt id="vendor-flag--fetch"><code id="fetch"><a href="#vendor-flag--fetch">--[no]fetch</a></code> default: "true"</dt>
<dd>
<p>Allows the command to fetch external dependencies. If set to false, the command will utilize any cached version of the dependency, and if none exists, the command will result in failure.</p>
</dd>
<dt id="vendor-flag--package_path"><code id="package_path"><a href="#vendor-flag--package_path">--package_path</a>=&lt;colon-separated list of options&gt;</code> default: "%workspace%"</dt>
<dd>
<p>A colon-separated list of where to look for packages. Elements beginning with '%workspace%' are relative to the enclosing workspace. If omitted or empty, the default is the output of 'bazel info default-package-path'.</p>
</dd>
<dt id="vendor-flag--show_loading_progress"><code id="show_loading_progress"><a href="#vendor-flag--show_loading_progress">--[no]show_loading_progress</a></code> default: "true"</dt>
<dd>
<p>If enabled, causes Bazel to print &quot;Loading package:&quot; messages.</p>
</dd>
</dl>

<dl>Options that control build execution:
<dt id="flag--experimental_persistent_aar_extractor"><code><a href="#flag--experimental_persistent_aar_extractor">--[no]experimental_persistent_aar_extractor</a></code> default: "false"</dt>
<dd>
<p>Enable persistent aar extractor by using workers.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_remotable_source_manifests"><code><a href="#flag--experimental_remotable_source_manifests">--[no]experimental_remotable_source_manifests</a></code> default: "false"</dt>
<dd>
<p>Whether to make source manifest actions remotable</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_split_coverage_postprocessing"><code><a href="#flag--experimental_split_coverage_postprocessing">--[no]experimental_split_coverage_postprocessing</a></code> default: "false"</dt>
<dd>
<p>If true, then Bazel will run coverage postprocessing for test in a new spawn.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_strict_fileset_output"><code><a href="#flag--experimental_strict_fileset_output">--[no]experimental_strict_fileset_output</a></code> default: "false"</dt>
<dd>
<p>If this option is enabled, filesets will treat all output artifacts as regular files. They will not traverse directories or be sensitive to symlinks.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--incompatible_modify_execution_info_additive"><code><a href="#flag--incompatible_modify_execution_info_additive">--[no]incompatible_modify_execution_info_additive</a></code> default: "true"</dt>
<dd>
<p>When enabled, passing multiple <code>--modify_execution_info</code> flags is additive.
When disabled, only the last flag is taken into account.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--modify_execution_info"><code><a href="#flag--modify_execution_info">--modify_execution_info</a>=&lt;regex=[+-]key,regex=[+-]key,...&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Add or remove keys from an action's execution info based on action mnemonic.
Applies only to actions which support execution info. Many common actions
support execution info, e.g. Genrule, CppCompile, Javac, StarlarkAction,
TestRunner. When specifying multiple values, order matters because
many regexes may apply to the same mnemonic.</p>
<p>Syntax: <code>regex=[+-]key,regex=[+-]key,...</code>.</p>
<p>Examples:</p>
<ul>
<li><code>.*=+x,.*=-y,.*=+z</code> adds <code>x</code> and <code>z</code> to, and removes <code>y</code> from, the execution info for all actions.</li>
<li><code>Genrule=+requires-x</code> adds <code>requires-x</code> to the execution info for all Genrule actions.</li>
<li><code>(?!Genrule).*=-requires-x</code> removes <code>requires-x</code> from the execution info for all non-Genrule actions.</li>
</ul>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--persistent_android_dex_desugar"><code><a href="#flag--persistent_android_dex_desugar">--persistent_android_dex_desugar</a></code></dt>
<dd>
<p>Enable persistent Android dex and desugar actions by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_android_dex_desugar">--internal_persistent_android_dex_desugar</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=Desugar=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=DexBuilder=worker</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_android_resource_processor"><code><a href="#flag--persistent_android_resource_processor">--persistent_android_resource_processor</a></code></dt>
<dd>
<p>Enable persistent Android resource processor by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_busybox_tools">--internal_persistent_busybox_tools</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AaptPackage=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceParser=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceValidator=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceCompiler=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=RClassGenerator=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceLink=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidAapt2=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidAssetMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidResourceMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidCompiledResourceMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=ManifestMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AndroidManifestMerger=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=Aapt2Optimize=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=AARGenerator=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=ProcessDatabinding=worker</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--strategy">--strategy=GenerateDataBindingBaseClasses=worker</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_multiplex_android_dex_desugar"><code><a href="#flag--persistent_multiplex_android_dex_desugar">--persistent_multiplex_android_dex_desugar</a></code></dt>
<dd>
<p>Enable persistent multiplexed Android dex and desugar actions by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_android_dex_desugar">--persistent_android_dex_desugar</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_multiplex_android_dex_desugar">--internal_persistent_multiplex_android_dex_desugar</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_multiplex_android_resource_processor"><code><a href="#flag--persistent_multiplex_android_resource_processor">--persistent_multiplex_android_resource_processor</a></code></dt>
<dd>
<p>Enable persistent multiplexed Android resource processor by using workers.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_android_resource_processor">--persistent_android_resource_processor</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AaptPackage=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceParser=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceValidator=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceCompiler=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=RClassGenerator=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceLink=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidAapt2=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidAssetMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidResourceMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidCompiledResourceMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=ManifestMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AndroidManifestMerger=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=Aapt2Optimize=+supports-multiplex-workers</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--modify_execution_info">--modify_execution_info=AARGenerator=+supports-multiplex-workers</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--persistent_multiplex_android_tools"><code><a href="#flag--persistent_multiplex_android_tools">--persistent_multiplex_android_tools</a></code></dt>
<dd>
<p>Enable persistent and multiplexed Android tools (dexing, desugaring, resource processing).</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--internal_persistent_multiplex_busybox_tools">--internal_persistent_multiplex_busybox_tools</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_multiplex_android_resource_processor">--persistent_multiplex_android_resource_processor</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--persistent_multiplex_android_dex_desugar">--persistent_multiplex_android_dex_desugar</a></code>
</p><p>Tags:
<a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--use_target_platform_for_tests"><code><a href="#flag--use_target_platform_for_tests">--[no]use_target_platform_for_tests</a></code> default: "false"</dt>
<dd>
<p>If true, use the target platform for running tests rather than the test exec group.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
</dl>
<dl>Options that configure the toolchain used for action execution:
<dt id="flag--android_compiler"><code><a href="#flag--android_compiler">--android_compiler</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The Android target compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--android_manifest_merger"><code><a href="#flag--android_manifest_merger">--android_manifest_merger</a>=&lt;legacy, android or force_android&gt;</code> default: "android"</dt>
<dd>
<p>Selects the manifest merger to use for android_binary rules. Flag to help the transition to the Android manifest merger from the legacy merger.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--android_platforms"><code><a href="#flag--android_platforms">--android_platforms</a>=&lt;a build target label&gt;</code> default: ""</dt>
<dd>
<p>Sets the platforms that android_binary targets use. If multiple platforms are specified, then the binary is a fat APKs, which contains native binaries for each specified target platform.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--cc_output_directory_tag"><code><a href="#flag--cc_output_directory_tag">--cc_output_directory_tag</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Specifies a suffix to be added to the configuration directory.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--compiler"><code><a href="#flag--compiler">--compiler</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The C++ compiler to use for compiling the target.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--coverage_output_generator"><code><a href="#flag--coverage_output_generator">--coverage_output_generator</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/test:lcov_merger"</dt>
<dd>
<p>Location of the binary that is used to postprocess raw coverage reports. This must
be a binary target. Defaults to <code>@bazel_tools//tools/test:lcov_merger</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--coverage_report_generator"><code><a href="#flag--coverage_report_generator">--coverage_report_generator</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/test:coverage_report_generator"</dt>
<dd>
<p>Location of the binary that is used to generate coverage reports. This must
be a binary target. Defaults to <code>@bazel_tools//tools/test:coverage_report_generator</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--coverage_support"><code><a href="#flag--coverage_support">--coverage_support</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/test:coverage_support"</dt>
<dd>
<p>Location of support files that are required on the inputs of every test action
that collects code coverage. Defaults to <code>//tools/test:coverage_support</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--custom_malloc"><code><a href="#flag--custom_malloc">--custom_malloc</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies a custom malloc implementation. This setting overrides malloc attributes in build rules.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--experimental_include_xcode_execution_requirements"><code><a href="#flag--experimental_include_xcode_execution_requirements">--[no]experimental_include_xcode_execution_requirements</a></code> default: "false"</dt>
<dd>
<p>If set, add a &quot;requires-xcode:{version}&quot; execution requirement to every Xcode action.  If the Xcode version has a hyphenated label,  also add a &quot;requires-xcode-label:{version_label}&quot; execution requirement.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_prefer_mutual_xcode"><code><a href="#flag--experimental_prefer_mutual_xcode">--[no]experimental_prefer_mutual_xcode</a></code> default: "true"</dt>
<dd>
<p>If true, use the most recent Xcode that is available both locally and remotely. If false, or if there are no mutual available versions, use the local Xcode version selected via xcode-select.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--extra_execution_platforms"><code><a href="#flag--extra_execution_platforms">--extra_execution_platforms</a>=&lt;comma-separated list of options&gt;</code> default: ""</dt>
<dd>
<p>The platforms that are available as execution platforms to run actions.
Platforms can be specified by exact target, or as a target pattern.
These platforms will be considered before those declared in the <code>WORKSPACE</code> file by
<code>register_execution_platforms()</code>. This option may only be set once; later
instances will override earlier flag settings.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--extra_toolchains"><code><a href="#flag--extra_toolchains">--extra_toolchains</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The toolchain rules to be considered during toolchain resolution.
Toolchains can be specified by exact target, or as a target pattern.
These toolchains will be considered before those declared in the <code>WORKSPACE</code> file
by <code>register_toolchains()</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--grte_top"><code><a href="#flag--grte_top">--grte_top</a>=&lt;a label&gt;</code> default: see description</dt>
<dd>
<p>A label to a checked-in libc library. The default value is selected by the crosstool toolchain, and you almost never need to override it.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_compiler"><code><a href="#flag--host_compiler">--host_compiler</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>No-op flag. Will be removed in a future release.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--host_grte_top"><code><a href="#flag--host_grte_top">--host_grte_top</a>=&lt;a label&gt;</code> default: see description</dt>
<dd>
<p>If specified, this setting overrides the libc top-level directory (--grte_top) for the exec configuration.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_platform"><code><a href="#flag--host_platform">--host_platform</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools:host_platform"</dt>
<dd>
<p>The label of a platform rule that describes the host system.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--incompatible_bazel_test_exec_run_under"><code><a href="#flag--incompatible_bazel_test_exec_run_under">--[no]incompatible_bazel_test_exec_run_under</a></code> default: "true"</dt>
<dd>
<p>If enabled, <code>bazel test --run_under=//:runner</code> builds <code>//:runner</code> in the exec
configuration. If disabled, it builds <code>//:runner</code> in the target configuration.
Bazel executes tests on exec machines, so the former is more correct. This
doesn't affect <code>bazel run</code>, which always builds <code>--run_under=//foo</code> in the
target configuration.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_builtin_objc_strip_action"><code><a href="#flag--incompatible_builtin_objc_strip_action">--[no]incompatible_builtin_objc_strip_action</a></code> default: "true"</dt>
<dd>
<p>Whether to emit a strip action as part of objc linking.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_dont_enable_host_nonhost_crosstool_features"><code><a href="#flag--incompatible_dont_enable_host_nonhost_crosstool_features">--[no]incompatible_dont_enable_host_nonhost_crosstool_features</a></code> default: "true"</dt>
<dd>
<p>If true, Bazel will not enable 'host' and 'nonhost' features in the c++ toolchain (see https://github.com/bazelbuild/bazel/issues/7407 for more information).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_enable_apple_toolchain_resolution"><code><a href="#flag--incompatible_enable_apple_toolchain_resolution">--[no]incompatible_enable_apple_toolchain_resolution</a></code> default: "false"</dt>
<dd>
<p>Use toolchain resolution to select the Apple SDK for apple rules (Starlark and native)</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_remove_legacy_whole_archive"><code><a href="#flag--incompatible_remove_legacy_whole_archive">--[no]incompatible_remove_legacy_whole_archive</a></code> default: "true"</dt>
<dd>
<p>If true, Bazel will not link library dependencies as whole archive by default (see https://github.com/bazelbuild/bazel/issues/7362 for migration instructions).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_strip_executable_safely"><code><a href="#flag--incompatible_strip_executable_safely">--[no]incompatible_strip_executable_safely</a></code> default: "false"</dt>
<dd>
<p>If true, strip action for executables will use flag -x, which does not break dynamic symbol resolution.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--interface_shared_objects"><code><a href="#flag--interface_shared_objects">--[no]interface_shared_objects</a></code> default: "true"</dt>
<dd>
<p>Use interface shared objects if supported by the toolchain. All ELF toolchains currently support this setting.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ios_sdk_version"><code><a href="#flag--ios_sdk_version">--ios_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the iOS SDK to use to build iOS applications. If unspecified, uses the default iOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--macos_sdk_version"><code><a href="#flag--macos_sdk_version">--macos_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the macOS SDK to use to build macOS applications. If unspecified, uses the default macOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--minimum_os_version"><code><a href="#flag--minimum_os_version">--minimum_os_version</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The minimum OS version which your compilation targets.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--platform_mappings"><code><a href="#flag--platform_mappings">--platform_mappings</a>=&lt;a main workspace-relative path&gt;</code> default: ""</dt>
<dd>
<p>The location of a mapping file that describes which platform to use if none is set or
which flags to set when a platform already exists. Must be relative to the main
workspace root. Defaults to <code>platform_mappings</code> (a file directly under the
workspace root).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--platforms"><code><a href="#flag--platforms">--platforms</a>=&lt;a build target label&gt;</code> default: ""</dt>
<dd>
<p>The labels of the platform rules describing the target platforms for the current command.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--python_path"><code><a href="#flag--python_path">--python_path</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The absolute path of the Python interpreter invoked to run Python targets on the
target platform. Deprecated; disabled by <code>--incompatible_use_python_toolchains</code>.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--tvos_sdk_version"><code><a href="#flag--tvos_sdk_version">--tvos_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the tvOS SDK to use to build tvOS applications. If unspecified, uses the default tvOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--use_platforms_in_apple_crosstool_transition"><code><a href="#flag--use_platforms_in_apple_crosstool_transition">--[no]use_platforms_in_apple_crosstool_transition</a></code> default: "false"</dt>
<dd>
<p>Makes apple_crosstool_transition fall back to using the value of <code>--platforms</code> flag instead of legacy <code>--cpu</code> when needed.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--watchos_sdk_version"><code><a href="#flag--watchos_sdk_version">--watchos_sdk_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Specifies the version of the watchOS SDK to use to build watchOS applications. If unspecified, uses the default watchOS SDK version from 'xcode_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--xcode_version"><code><a href="#flag--xcode_version">--xcode_version</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>If specified, uses Xcode of the given version for relevant build actions. If unspecified, uses the executor default version of Xcode.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--xcode_version_config"><code><a href="#flag--xcode_version_config">--xcode_version_config</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/cpp:host_xcodes"</dt>
<dd>
<p>The label of the xcode_config rule to be used for selecting the Xcode version in the build configuration.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
</dl>
<dl>Options that control the output of the command:
<dt id="flag--apple_generate_dsym"><code><a href="#flag--apple_generate_dsym">--[no]apple_generate_dsym</a></code> default: "false"</dt>
<dd>
<p>Whether to generate debug symbol(.dSYM) file(s).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--build_runfile_links"><code><a href="#flag--build_runfile_links">--[no]build_runfile_links</a></code> default: "true"</dt>
<dd>
<p>If true, build runfiles symlink forests for all targets.  If false, write them only when required by a local action, test or run command.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--build_runfile_manifests"><code><a href="#flag--build_runfile_manifests">--[no]build_runfile_manifests</a></code> default: "true"</dt>
<dd>
<p>If true, write runfiles manifests for all targets. If false, omit them. Local tests will fail to run when false.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--build_test_dwp"><code><a href="#flag--build_test_dwp">--[no]build_test_dwp</a></code> default: "false"</dt>
<dd>
<p>If enabled, when building C++ tests statically and with fission the .dwp file  for the test binary will be automatically built as well.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cc_proto_library_header_suffixes"><code><a href="#flag--cc_proto_library_header_suffixes">--cc_proto_library_header_suffixes</a>=&lt;comma-separated set of options&gt;</code> default: ".pb.h"</dt>
<dd>
<p>Sets the suffixes of header files that a cc_proto_library creates.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--cc_proto_library_source_suffixes"><code><a href="#flag--cc_proto_library_source_suffixes">--cc_proto_library_source_suffixes</a>=&lt;comma-separated set of options&gt;</code> default: ".pb.cc"</dt>
<dd>
<p>Sets the suffixes of source files that a cc_proto_library creates.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--experimental_proto_descriptor_sets_include_source_info"><code><a href="#flag--experimental_proto_descriptor_sets_include_source_info">--[no]experimental_proto_descriptor_sets_include_source_info</a></code> default: "false"</dt>
<dd>
<p>Run extra actions for alternative Java api versions in a proto_library.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_save_feature_state"><code><a href="#flag--experimental_save_feature_state">--[no]experimental_save_feature_state</a></code> default: "false"</dt>
<dd>
<p>Save the state of enabled and requested feautres as an output of compilation.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--fission"><code><a href="#flag--fission">--fission</a>=&lt;a set of compilation modes&gt;</code> default: "no"</dt>
<dd>
<p>Specifies which compilation modes use fission for C++ compilations and links.  May be any combination of {'fastbuild', 'dbg', 'opt'} or the special values 'yes'  to enable all modes and 'no' to disable all modes.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--incompatible_always_include_files_in_data"><code><a href="#flag--incompatible_always_include_files_in_data">--[no]incompatible_always_include_files_in_data</a></code> default: "true"</dt>
<dd>
<p>If true, native rules add <code>DefaultInfo.files</code> of data dependencies to their runfiles,
which matches the recommended behavior for Starlark rules (<a href="https://bazel.build/extending/rules#runfiles_features_to_avoid">runfiles features to avoid</a>).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_compact_repo_mapping_manifest"><code><a href="#flag--incompatible_compact_repo_mapping_manifest">--[no]incompatible_compact_repo_mapping_manifest</a></code> default: "false"</dt>
<dd>
<p>If enabled, the <code>{binary}.repo_mapping</code> file emits a module extension's repo mapping
only once instead of once for each repo generated by the extension that
contributes runfiles.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_disable_select_on"><code><a href="#flag--incompatible_disable_select_on">--incompatible_disable_select_on</a>=&lt;comma-separated set of options&gt;</code> default: ""</dt>
<dd>
<p>List of flags for which the use in <code>select()</code> is disabled.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--incompatible_filegroup_runfiles_for_data"><code><a href="#flag--incompatible_filegroup_runfiles_for_data">--[no]incompatible_filegroup_runfiles_for_data</a></code> default: "true"</dt>
<dd>
<p>If true, runfiles of targets listed in the srcs attribute are available to targets that consume the filegroup as a data dependency.</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--objc_generate_linkmap"><code><a href="#flag--objc_generate_linkmap">--[no]objc_generate_linkmap</a></code> default: "false"</dt>
<dd>
<p>Specifies whether to generate a linkmap file.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--save_temps"><code><a href="#flag--save_temps">--[no]save_temps</a></code> default: "false"</dt>
<dd>
<p>If set, temporary outputs from gcc will be saved.  These include .s files (assembler code), .i files (preprocessed C) and .ii files (preprocessed C++).</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
</dl>
<dl>Options that let the user configure the intended output, affecting its value, as opposed to its existence:
<dt id="flag--action_env"><code><a href="#flag--action_env">--action_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the set of environment variables available to actions with target
configuration. Variables can be either specified by <code>name</code>, in which case
the value will be taken from the invocation environment, by the <code>name=value</code>
pair which sets the value independent of the invocation environment, or by
<code>=name</code>, which unsets the variable of that name. This option can be used
multiple times; for options given for the same variable, the latest wins,
options for different variables accumulate.</p>
<p>Note that unless <code>--incompatible_repo_env_ignores_action_env</code> is true, all <code>name=value</code>
pairs will be available to repository rules.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--allowed_cpu_values"><code><a href="#flag--allowed_cpu_values">--allowed_cpu_values</a>=&lt;comma-separated set of options&gt;</code> default: ""</dt>
<dd>
<p>Allowed values for the <code>--cpu</code> flag.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--android_databinding_use_androidx"><code><a href="#flag--android_databinding_use_androidx">--[no]android_databinding_use_androidx</a></code> default: "true"</dt>
<dd>
<p>Generate AndroidX-compatible data-binding files. This is only used with databinding v2. This flag is a no-op.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--android_databinding_use_v3_4_args"><code><a href="#flag--android_databinding_use_v3_4_args">--[no]android_databinding_use_v3_4_args</a></code> default: "true"</dt>
<dd>
<p>Use android databinding v2 with 3.4.0 argument. This flag is a no-op.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--android_dynamic_mode"><code><a href="#flag--android_dynamic_mode">--android_dynamic_mode</a>=&lt;off, default or fully&gt;</code> default: "off"</dt>
<dd>
<p>Determines whether C++ deps of Android rules will be linked dynamically when a cc_binary does not explicitly create a shared library. 'default' means bazel will choose whether to link dynamically.  'fully' means all libraries will be linked dynamically. 'off' means that all libraries will be linked in mostly static mode.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--android_manifest_merger_order"><code><a href="#flag--android_manifest_merger_order">--android_manifest_merger_order</a>=&lt;alphabetical, alphabetical_by_configuration or dependency&gt;</code> default: "alphabetical"</dt>
<dd>
<p>Sets the order of manifests passed to the manifest merger for Android binaries. ALPHABETICAL means manifests are sorted by path relative to the execroot. ALPHABETICAL_BY_CONFIGURATION means manifests are sorted by paths relative to the configuration directory within the output directory. DEPENDENCY means manifests are ordered with each library's manifest coming before the manifests of its dependencies.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--android_resource_shrinking"><code><a href="#flag--android_resource_shrinking">--[no]android_resource_shrinking</a></code> default: "false"</dt>
<dd>
<p>Enables resource shrinking for android_binary APKs that use ProGuard.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--build_python_zip"><code><a href="#flag--build_python_zip">--[no]build_python_zip</a></code> default: "auto"</dt>
<dd>
<p>Build python executable zip; on on Windows, off on other platforms</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--catalyst_cpus"><code><a href="#flag--catalyst_cpus">--catalyst_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple Catalyst binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--collect_code_coverage"><code><a href="#flag--collect_code_coverage">--[no]collect_code_coverage</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will instrument code (using offline instrumentation where
possible) and will collect coverage information during tests. Only targets that
match <code>--instrumentation_filter</code> will be affected. Usually this option should
not be specified directly - <code>bazel coverage</code> command should be used instead.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--compilation_mode"><code><a href="#flag--compilation_mode">--compilation_mode</a>=&lt;fastbuild, dbg or opt&gt;</code> [<code>-c</code>] default: "fastbuild"</dt>
<dd>
<p>Specify the mode the binary will be built in. Values: <code>fastbuild</code>, <code>dbg</code>, <code>opt</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--conlyopt"><code><a href="#flag--conlyopt">--conlyopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to gcc when compiling C source files.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--copt"><code><a href="#flag--copt">--copt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to gcc.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cpu"><code><a href="#flag--cpu">--cpu</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>Deprecated: this flag is not used internally by Blaze although there are legacy platform
mappings to allow for backwards compatibility. Do not use this flag, instead use
<code>--platforms</code> with an appropriate platform definition.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cs_fdo_absolute_path"><code><a href="#flag--cs_fdo_absolute_path">--cs_fdo_absolute_path</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Use CSFDO profile information to optimize compilation. Specify the absolute path name of the zip file containing the profile file, a raw or an indexed LLVM profile file.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cs_fdo_instrument"><code><a href="#flag--cs_fdo_instrument">--cs_fdo_instrument</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Generate binaries with context sensitive FDO instrumentation. With Clang/LLVM compiler, it also accepts the directory name under which the raw profile file(s) will be dumped at runtime.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cs_fdo_profile"><code><a href="#flag--cs_fdo_profile">--cs_fdo_profile</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The cs_fdo_profile representing the context sensitive profile to be used for optimization.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--cxxopt"><code><a href="#flag--cxxopt">--cxxopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to gcc when compiling C++ source files.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--define"><code><a href="#flag--define">--define</a>=&lt;a &#39;name=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Each <code>--define</code> option specifies an assignment for a build variable.
In case of multiple values for a variable, the last one wins.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--dynamic_mode"><code><a href="#flag--dynamic_mode">--dynamic_mode</a>=&lt;off, default or fully&gt;</code> default: "default"</dt>
<dd>
<p>Determines whether C++ binaries will be linked dynamically.  'default' means Bazel will choose whether to link dynamically.  'fully' means all libraries will be linked dynamically. 'off' means that all libraries will be linked in mostly static mode.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--enable_propeller_optimize_absolute_paths"><code><a href="#flag--enable_propeller_optimize_absolute_paths">--[no]enable_propeller_optimize_absolute_paths</a></code> default: "true"</dt>
<dd>
<p>If set, any use of absolute paths for propeller optimize will raise an error.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--enable_remaining_fdo_absolute_paths"><code><a href="#flag--enable_remaining_fdo_absolute_paths">--[no]enable_remaining_fdo_absolute_paths</a></code> default: "true"</dt>
<dd>
<p>If set, any use of absolute paths for FDO will raise an error.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--enable_runfiles"><code><a href="#flag--enable_runfiles">--[no]enable_runfiles</a></code> default: "auto"</dt>
<dd>
<p>Enable runfiles symlink tree; By default, it's off on Windows, on on other platforms.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--exec_aspects"><code><a href="#flag--exec_aspects">--exec_aspects</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of aspects to be applied to exec-configured targets, regardless of whether or not they are top-level targets. This is an experimental feature and is subject to change.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--experimental_action_listener"><code><a href="#flag--experimental_action_listener">--experimental_action_listener</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Deprecated in favor of aspects. Use <code>action_listener</code> to attach an <code>extra_action</code> to
existing build actions.</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_compress_java_resources"><code><a href="#flag--experimental_android_compress_java_resources">--[no]experimental_android_compress_java_resources</a></code> default: "false"</dt>
<dd>
<p>Compress Java resources in APKs</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_databinding_v2"><code><a href="#flag--experimental_android_databinding_v2">--[no]experimental_android_databinding_v2</a></code> default: "true"</dt>
<dd>
<p>Use android databinding v2. This flag is a no-op.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_resource_shrinking"><code><a href="#flag--experimental_android_resource_shrinking">--[no]experimental_android_resource_shrinking</a></code> default: "false"</dt>
<dd>
<p>Enables resource shrinking for android_binary APKs that use ProGuard.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_android_rewrite_dexes_with_rex"><code><a href="#flag--experimental_android_rewrite_dexes_with_rex">--[no]experimental_android_rewrite_dexes_with_rex</a></code> default: "false"</dt>
<dd>
<p>use rex tool to rewrite dex files</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_collect_code_coverage_for_generated_files"><code><a href="#flag--experimental_collect_code_coverage_for_generated_files">--[no]experimental_collect_code_coverage_for_generated_files</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will also generate collect coverage information for generated files.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_objc_fastbuild_options"><code><a href="#flag--experimental_objc_fastbuild_options">--experimental_objc_fastbuild_options</a>=&lt;comma-separated list of options&gt;</code> default: "-O0,-DDEBUG=1"</dt>
<dd>
<p>Uses these strings as objc fastbuild compiler options.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--experimental_omitfp"><code><a href="#flag--experimental_omitfp">--[no]experimental_omitfp</a></code> default: "false"</dt>
<dd>
<p>If true, use libunwind for stack unwinding, and compile with -fomit-frame-pointer and -fasynchronous-unwind-tables.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_output_paths"><code><a href="#flag--experimental_output_paths">--experimental_output_paths</a>=&lt;off or strip&gt;</code> default: "off"</dt>
<dd>
<p>Which model to use for where in the output tree rules write their outputs, particularly
for multi-platform / multi-configuration builds. This is highly experimental. See
<a href="https://github.com/bazelbuild/bazel/issues/6526">GH-6526</a> for details. Starlark actions can opt into path mapping by adding the key
<code>supports-path-mapping</code> to the <code>execution_requirements</code> dict.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--experimental_override_platform_cpu_name"><code><a href="#flag--experimental_override_platform_cpu_name">--experimental_override_platform_cpu_name</a>=&lt;a &#39;label=value&#39; assignment&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Each entry should be of the form <code>label=value</code> where label refers to a platform and values
is the desired shortname to override the platform's CPU name in <code>$(TARGET_CPU)</code>
make variable and output path. Only used when
<code>--experimental_platform_in_output_dir</code>, <code>--incompatible_target_cpu_from_platform</code> or
<code>--incompatible_bep_cpu_from_platform</code> is true. Has highest naming priority.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_platform_in_output_dir"><code><a href="#flag--experimental_platform_in_output_dir">--[no]experimental_platform_in_output_dir</a></code> default: "Auto"</dt>
<dd>
<p>If true, a shortname for the target platform is used in the output directory name
instead of the CPU. The exact scheme is experimental and subject to change:</p>
<ol>
<li>First, in the rare case the <code>--platforms</code> option does not have exactly one value, a
hash of the platforms option is used.</li>
<li>Next, if any shortname for the current platform was registered by
<code>--experimental_override_name_platform_in_output_dir</code>, then that shortname is used.</li>
<li>Then, if <code>--experimental_use_platforms_in_output_dir_legacy_heuristic</code> is set, use a
shortname based off the current platform Label.</li>
<li>Finally, a hash of the platform option is used as a last resort.</li>
</ol>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_py_binaries_include_label"><code><a href="#flag--experimental_py_binaries_include_label">--[no]experimental_py_binaries_include_label</a></code> default: "false"</dt>
<dd>
<p>py_binary targets include their label even when stamping is disabled.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_use_llvm_covmap"><code><a href="#flag--experimental_use_llvm_covmap">--[no]experimental_use_llvm_covmap</a></code> default: "false"</dt>
<dd>
<p>If specified, Bazel will generate llvm-cov coverage map information rather than gcov when collect_code_coverage is enabled.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_use_platforms_in_output_dir_legacy_heuristic"><code><a href="#flag--experimental_use_platforms_in_output_dir_legacy_heuristic">--[no]experimental_use_platforms_in_output_dir_legacy_heuristic</a></code> default: "true"</dt>
<dd>
<p>Please only use this flag as part of a suggested migration or testing strategy. Note
that the heuristic has known deficiencies and it is suggested to migrate to
relying on just <code>--experimental_override_name_platform_in_output_dir</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--fdo_instrument"><code><a href="#flag--fdo_instrument">--fdo_instrument</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Generate binaries with FDO instrumentation. With Clang/LLVM compiler, it also accepts the directory name under which the raw profile file(s) will be dumped at runtime.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--fdo_optimize"><code><a href="#flag--fdo_optimize">--fdo_optimize</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Use FDO profile information to optimize compilation. Specify the name of a zip file containing a .gcda file tree, an afdo file containing an auto profile, or an LLVM profile file. This flag also accepts files specified as labels (e.g. <code>//foo/bar:file.afdo</code> - you may need to add an <code>exports_files</code> directive to the corresponding package) and labels pointing to <code>fdo_profile</code> targets. This flag will be superseded by the <code>fdo_profile</code> rule.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--fdo_prefetch_hints"><code><a href="#flag--fdo_prefetch_hints">--fdo_prefetch_hints</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use cache prefetch hints.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--fdo_profile"><code><a href="#flag--fdo_profile">--fdo_profile</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The fdo_profile representing the profile to be used for optimization.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--features"><code><a href="#flag--features">--features</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The given features will be enabled or disabled by default for targets built in the target configuration.
Specifying <code>-{feature}</code> will disable the feature. Negative features always override positive ones.
See also <code>--host_features</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--force_pic"><code><a href="#flag--force_pic">--[no]force_pic</a></code> default: "false"</dt>
<dd>
<p>If enabled, all C++ compilations produce position-independent code (&quot;-fPIC&quot;), links prefer PIC pre-built libraries over non-PIC libraries, and links produce position-independent executables (&quot;-pie&quot;).</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_action_env"><code><a href="#flag--host_action_env">--host_action_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies the set of environment variables available to actions with execution
configurations. Variables can be either specified by <code>name</code>, in which case the
value will be taken from the invocation environment, by the <code>name=value</code> pair
which sets the value independent of the invocation environment, or by
<code>=name</code>, which unsets the variable of that name. This option can
be used multiple times; for options given for the same variable, the latest
wins, options for different variables accumulate.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--host_compilation_mode"><code><a href="#flag--host_compilation_mode">--host_compilation_mode</a>=&lt;fastbuild, dbg or opt&gt;</code> default: "opt"</dt>
<dd>
<p>Specify the mode the tools used during the build will be built in. Values:
<code>fastbuild</code>, <code>dbg</code>, <code>opt</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--host_conlyopt"><code><a href="#flag--host_conlyopt">--host_conlyopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to the C compiler when compiling C (but not C++) source files in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_copt"><code><a href="#flag--host_copt">--host_copt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the C compiler for tools built in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_cpu"><code><a href="#flag--host_cpu">--host_cpu</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The host CPU.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_cxxopt"><code><a href="#flag--host_cxxopt">--host_cxxopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to C++ compiler for tools built in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_features"><code><a href="#flag--host_features">--host_features</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>The given features will be enabled or disabled by default for targets built in the exec configuration.
Specifying <code>-{feature}</code> will disable the feature. Negative features always override positive ones.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_linkopt"><code><a href="#flag--host_linkopt">--host_linkopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to linker when linking tools in the exec configurations.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--host_macos_minimum_os"><code><a href="#flag--host_macos_minimum_os">--host_macos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible macOS version for host targets. If unspecified, uses 'macos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--host_per_file_copt"><code><a href="#flag--host_per_file_copt">--host_per_file_copt</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths followed by an @ and a comma separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to selectively pass to the C/C++ compiler when compiling certain files in the exec configurations. This option can be passed multiple times. Syntax: regex_filter@option_1,option_2,...,option_n. Where regex_filter stands for a list of include and exclude regular expression patterns (Also see --instrumentation_filter). option_1 to option_n stand for arbitrary command line options. If an option contains a comma it has to be quoted with a backslash. Options can contain @. Only the first @ is used to split the string. Example: --host_per_file_copt=//foo/.*.cc,-//foo/bar.cc@-O0 adds the -O0 command line option to the gcc command line of all cc files in //foo/ except bar.cc.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--incompatible_auto_exec_groups"><code><a href="#flag--incompatible_auto_exec_groups">--[no]incompatible_auto_exec_groups</a></code> default: "false"</dt>
<dd>
<p>When enabled, an exec groups is automatically created for each toolchain used by a rule.
For this to work rule needs to specify <code>toolchain</code> parameter on its actions. For
more information, see <a href="https://github.com/bazelbuild/bazel/issues/17134">GH-17134</a>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_merge_genfiles_directory"><code><a href="#flag--incompatible_merge_genfiles_directory">--[no]incompatible_merge_genfiles_directory</a></code> default: "true"</dt>
<dd>
<p>If true, the genfiles directory is folded into the bin directory.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_target_cpu_from_platform"><code><a href="#flag--incompatible_target_cpu_from_platform">--[no]incompatible_target_cpu_from_platform</a></code> default: "true"</dt>
<dd>
<p>If specified, the value of the cpu constraint (<code>@platforms//cpu:cpu</code>) of
the target platform is used to set the <code>$(TARGET_CPU)</code> make variable.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--instrument_test_targets"><code><a href="#flag--instrument_test_targets">--[no]instrument_test_targets</a></code> default: "false"</dt>
<dd>
<p>When coverage is enabled, specifies whether to consider instrumenting test rules.
When set, test rules included by <code>--instrumentation_filter</code> are instrumented.
Otherwise, test rules are always excluded from coverage instrumentation.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--instrumentation_filter"><code><a href="#flag--instrumentation_filter">--instrumentation_filter</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths&gt;</code> default: "-/javatests[/:],-/test/java[/:]"</dt>
<dd>
<p>When coverage is enabled, only rules with names included by the
specified regex-based filter will be instrumented. Rules prefixed
with '-' are excluded instead. Note that only non-test rules are
instrumented unless <code>--instrument_test_targets</code> is enabled.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ios_minimum_os"><code><a href="#flag--ios_minimum_os">--ios_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible iOS version for target simulators and devices. If unspecified, uses 'ios_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--ios_multi_cpus"><code><a href="#flag--ios_multi_cpus">--ios_multi_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures to build an ios_application with. The result is a universal binary containing all specified architectures.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--legacy_whole_archive"><code><a href="#flag--legacy_whole_archive">--[no]legacy_whole_archive</a></code> default: "true"</dt>
<dd>
<p>Deprecated, superseded by --incompatible_remove_legacy_whole_archive (see https://github.com/bazelbuild/bazel/issues/7362 for details). When on, use --whole-archive for cc_binary rules that have linkshared=True and either linkstatic=True or '-static' in linkopts. This is for backwards compatibility only. A better alternative is to use alwayslink=1 where required.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_DEPRECATED"><code>deprecated</code></a>
</p></dd>
<dt id="flag--linkopt"><code><a href="#flag--linkopt">--linkopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to gcc when linking.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ltobackendopt"><code><a href="#flag--ltobackendopt">--ltobackendopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to the LTO backend step (under --features=thin_lto).</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--ltoindexopt"><code><a href="#flag--ltoindexopt">--ltoindexopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional option to pass to the LTO indexing step (under --features=thin_lto).</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--macos_cpus"><code><a href="#flag--macos_cpus">--macos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple macOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--macos_minimum_os"><code><a href="#flag--macos_minimum_os">--macos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible macOS version for targets. If unspecified, uses 'macos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--memprof_profile"><code><a href="#flag--memprof_profile">--memprof_profile</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use memprof profile.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--objc_debug_with_GLIBCXX"><code><a href="#flag--objc_debug_with_GLIBCXX">--[no]objc_debug_with_GLIBCXX</a></code> default: "false"</dt>
<dd>
<p>If set, and compilation mode is set to 'dbg', define GLIBCXX_DEBUG,  GLIBCXX_DEBUG_PEDANTIC and GLIBCPP_CONCEPT_CHECKS.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--objc_enable_binary_stripping"><code><a href="#flag--objc_enable_binary_stripping">--[no]objc_enable_binary_stripping</a></code> default: "false"</dt>
<dd>
<p>Whether to perform symbol and dead-code strippings on linked binaries. Binary strippings will be performed if both this flag and --compilation_mode=opt are specified.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--objccopt"><code><a href="#flag--objccopt">--objccopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to gcc when compiling Objective-C/C++ source files.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--per_file_copt"><code><a href="#flag--per_file_copt">--per_file_copt</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths followed by an @ and a comma separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to selectively pass to gcc when compiling certain files. This option can be passed multiple times. Syntax: regex_filter@option_1,option_2,...,option_n. Where regex_filter stands for a list of include and exclude regular expression patterns (Also see --instrumentation_filter). option_1 to option_n stand for arbitrary command line options. If an option contains a comma it has to be quoted with a backslash. Options can contain @. Only the first @ is used to split the string. Example: --per_file_copt=//foo/.*.cc,-//foo/bar.cc@-O0 adds the -O0 command line option to the gcc command line of all cc files in //foo/ except bar.cc.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--per_file_ltobackendopt"><code><a href="#flag--per_file_ltobackendopt">--per_file_ltobackendopt</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths followed by an @ and a comma separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to selectively pass to LTO backend (under --features=thin_lto) when compiling certain backend objects. This option can be passed multiple times. Syntax: regex_filter@option_1,option_2,...,option_n. Where regex_filter stands for a list of include and exclude regular expression patterns. option_1 to option_n stand for arbitrary command line options. If an option contains a comma it has to be quoted with a backslash. Options can contain @. Only the first @ is used to split the string. Example: --per_file_ltobackendopt=//foo/.*.o,-//foo/bar.o@-O0 adds the -O0 command line option to the LTO backend command line of all o files in //foo/ except bar.o.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--platform_suffix"><code><a href="#flag--platform_suffix">--platform_suffix</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specifies a suffix to be added to the configuration directory.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--propeller_optimize"><code><a href="#flag--propeller_optimize">--propeller_optimize</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use Propeller profile information to optimize the build target.A propeller profile must consist of at least one of two files, a cc profile and a ld profile.  This flag accepts a build label which must refer to the propeller profile input files. For example, the BUILD file that defines the label, in a/b/BUILD:propeller_optimize(    name = &quot;propeller_profile&quot;,    cc_profile = &quot;propeller_cc_profile.txt&quot;,    ld_profile = &quot;propeller_ld_profile.txt&quot;,)An exports_files directive may have to be added to the corresponding package to make these files visible to Bazel. The option must be used as: --propeller_optimize=//a/b:propeller_profile</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--propeller_optimize_absolute_cc_profile"><code><a href="#flag--propeller_optimize_absolute_cc_profile">--propeller_optimize_absolute_cc_profile</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Absolute path name of cc_profile file for Propeller Optimized builds.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--propeller_optimize_absolute_ld_profile"><code><a href="#flag--propeller_optimize_absolute_ld_profile">--propeller_optimize_absolute_ld_profile</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Absolute path name of ld_profile file for Propeller Optimized builds.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--run_under"><code><a href="#flag--run_under">--run_under</a>=&lt;a prefix in front of command&gt;</code> default: see description</dt>
<dd>
<p>Prefix to insert before the executables for the <code>test</code> and <code>run</code> commands.
If the value is <code>foo -bar</code>, and the execution command line is <code>test_binary -baz</code>,
then the final command line is <code>foo -bar test_binary -baz</code>.
This can also be a label to an executable target. Some examples are:</p>
<ul>
<li><code>valgrind</code></li>
<li><code>strace</code></li>
<li><code>strace -c</code></li>
<li><code>valgrind --quiet --num-callers=20</code></li>
<li><code>//package:target</code></li>
<li><code>//package:target --options</code></li>
</ul>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--share_native_deps"><code><a href="#flag--share_native_deps">--[no]share_native_deps</a></code> default: "true"</dt>
<dd>
<p>If true, native libraries that contain identical functionality will be shared among different targets</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--stamp"><code><a href="#flag--stamp">--[no]stamp</a></code> default: "false"</dt>
<dd>
<p>Stamp binaries with the date, username, hostname, workspace information, etc.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--strip"><code><a href="#flag--strip">--strip</a>=&lt;always, sometimes or never&gt;</code> default: "sometimes"</dt>
<dd>
<p>Specifies whether to strip binaries and shared libraries  (using &quot;-Wl,--strip-debug&quot;).  The default value of 'sometimes' means strip iff --compilation_mode=fastbuild.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--stripopt"><code><a href="#flag--stripopt">--stripopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to strip when generating a '&lt;name&gt;.stripped' binary.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--tvos_cpus"><code><a href="#flag--tvos_cpus">--tvos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple tvOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--tvos_minimum_os"><code><a href="#flag--tvos_minimum_os">--tvos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible tvOS version for target simulators and devices. If unspecified, uses 'tvos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--visionos_cpus"><code><a href="#flag--visionos_cpus">--visionos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple visionOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--watchos_cpus"><code><a href="#flag--watchos_cpus">--watchos_cpus</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Comma-separated list of architectures for which to build Apple watchOS binaries.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--watchos_minimum_os"><code><a href="#flag--watchos_minimum_os">--watchos_minimum_os</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>Minimum compatible watchOS version for target simulators and devices. If unspecified, uses 'watchos_sdk_version'.</p>
<p>Tags:
<a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--xbinary_fdo"><code><a href="#flag--xbinary_fdo">--xbinary_fdo</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Use XbinaryFDO profile information to optimize compilation. Specify the name of default cross binary profile. When the option is used together with --fdo_instrument/--fdo_optimize/--fdo_profile, those options will always prevail as if xbinary_fdo is never specified.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
</dl>
<dl>Options that affect how strictly Bazel enforces valid build inputs (rule definitions,  flag combinations, etc.):
<dt id="flag--check_visibility"><code><a href="#flag--check_visibility">--[no]check_visibility</a></code> default: "true"</dt>
<dd>
<p>If disabled, visibility errors in target dependencies are demoted to warnings.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--desugar_for_android"><code><a href="#flag--desugar_for_android">--[no]desugar_for_android</a></code> default: "true"</dt>
<dd>
<p>Whether to desugar Java 8 bytecode before dexing.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--desugar_java8_libs"><code><a href="#flag--desugar_java8_libs">--[no]desugar_java8_libs</a></code> default: "false"</dt>
<dd>
<p>Whether to include supported Java 8 libraries in apps for legacy devices.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--enforce_constraints"><code><a href="#flag--enforce_constraints">--[no]enforce_constraints</a></code> default: "true"</dt>
<dd>
<p>Checks the environments each target is compatible with and reports errors if any target has dependencies that don't support the same environments</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>
</p></dd>
<dt id="flag--experimental_check_desugar_deps"><code><a href="#flag--experimental_check_desugar_deps">--[no]experimental_check_desugar_deps</a></code> default: "true"</dt>
<dd>
<p>Whether to double-check correct desugaring at Android binary level.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_enforce_transitive_visibility"><code><a href="#flag--experimental_enforce_transitive_visibility">--[no]experimental_enforce_transitive_visibility</a></code> default: "false"</dt>
<dd>
<p>If true, enable package()s to set the transitive_visibility attribute to restrict which packages may depend on them.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_one_version_enforcement"><code><a href="#flag--experimental_one_version_enforcement">--experimental_one_version_enforcement</a>=&lt;off, warning or error&gt;</code> default: "OFF"</dt>
<dd>
<p>When enabled, enforce that a java_binary rule can't contain more than one version of the same class file on the classpath. This enforcement can break the build, or can just result in warnings.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--experimental_strict_java_deps"><code><a href="#flag--experimental_strict_java_deps">--experimental_strict_java_deps</a>=&lt;off, warn, error, strict or default&gt;</code> default: "default"</dt>
<dd>
<p>If true, checks that a Java target explicitly declares all directly used targets as dependencies.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="flag--incompatible_check_testonly_for_output_files"><code><a href="#flag--incompatible_check_testonly_for_output_files">--[no]incompatible_check_testonly_for_output_files</a></code> default: "false"</dt>
<dd>
<p>If enabled, check testonly for prerequisite targets that are output files by looking up the testonly of the generating rule. This matches visibility checking.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_disable_native_android_rules"><code><a href="#flag--incompatible_disable_native_android_rules">--[no]incompatible_disable_native_android_rules</a></code> default: "false"</dt>
<dd>
<p>If enabled, direct usage of the native Android rules is disabled. Please use the Starlark Android rules from https://github.com/bazelbuild/rules_android</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_disable_native_apple_binary_rule"><code><a href="#flag--incompatible_disable_native_apple_binary_rule">--[no]incompatible_disable_native_apple_binary_rule</a></code> default: "false"</dt>
<dd>
<p>No-op. Kept here for backwards compatibility.</p>
<p>Tags:
<a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--one_version_enforcement_on_java_tests"><code><a href="#flag--one_version_enforcement_on_java_tests">--[no]one_version_enforcement_on_java_tests</a></code> default: "true"</dt>
<dd>
<p>When enabled, and with experimental_one_version_enforcement set to a non-NONE value, enforce one version on java_test targets. This flag can be disabled to improve incremental test performance at the expense of missing potential one version violations.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--python_native_rules_allowlist"><code><a href="#flag--python_native_rules_allowlist">--python_native_rules_allowlist</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>An allowlist (package_group target) to use when enforcing --incompatible_python_disallow_native_rules.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--strict_filesets"><code><a href="#flag--strict_filesets">--[no]strict_filesets</a></code> default: "false"</dt>
<dd>
<p>If this option is enabled, filesets crossing package boundaries are reported as errors.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="flag--strict_proto_deps"><code><a href="#flag--strict_proto_deps">--strict_proto_deps</a>=&lt;off, warn, error, strict or default&gt;</code> default: "error"</dt>
<dd>
<p>Unless OFF, checks that a proto_library target explicitly declares all directly used targets as dependencies.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--strict_public_imports"><code><a href="#flag--strict_public_imports">--strict_public_imports</a>=&lt;off, warn, error, strict or default&gt;</code> default: "off"</dt>
<dd>
<p>Unless OFF, checks that a proto_library target explicitly declares all targets used in 'import public' as exported.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--strict_system_includes"><code><a href="#flag--strict_system_includes">--[no]strict_system_includes</a></code> default: "false"</dt>
<dd>
<p>If true, headers found through system include paths (-isystem) are also required to be declared.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></a>
</p></dd>
<dt id="flag--target_environment"><code><a href="#flag--target_environment">--target_environment</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Declares this build's target environment. Must be a label reference to an
<a href="https://github.com/bazelbuild/bazel/blob/master/src/main/java/com/google/devtools/build/lib/analysis/constraints/EnvironmentRule.java"><code>environment</code> rule</a>. If specified, all top-level targets must be compatible with this
environment.</p>
<p>See also <code>--platforms</code>.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
</dl>
<dl>Options that affect the signing outputs of a build:
<dt id="flag--apk_signing_method"><code><a href="#flag--apk_signing_method">--apk_signing_method</a>=&lt;v1, v2, v1_v2 or v4&gt;</code> default: "v1_v2"</dt>
<dd>
<p>Implementation to use to sign APKs</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--device_debug_entitlements"><code><a href="#flag--device_debug_entitlements">--[no]device_debug_entitlements</a></code> default: "true"</dt>
<dd>
<p>If set, and compilation mode is not 'opt', objc apps will include debug entitlements when signing.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="flag--ios_signing_cert_name"><code><a href="#flag--ios_signing_cert_name">--ios_signing_cert_name</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Certificate name to use for iOS signing. If not set will fall back to provisioning profile. May be the certificate's keychain identity preference or (substring) of the certificate's common name, as per codesign's man page (SIGNING IDENTITIES).</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
</dl>
<dl>This option affects semantics of the Starlark language or the build API accessible to BUILD files, .bzl files, or WORKSPACE files.:
<dt id="flag--incompatible_disallow_sdk_frameworks_attributes"><code><a href="#flag--incompatible_disallow_sdk_frameworks_attributes">--[no]incompatible_disallow_sdk_frameworks_attributes</a></code> default: "false"</dt>
<dd>
<p>If true, disallow sdk_frameworks and weak_sdk_frameworks attributes in objc_library andobjc_import.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_objc_alwayslink_by_default"><code><a href="#flag--incompatible_objc_alwayslink_by_default">--[no]incompatible_objc_alwayslink_by_default</a></code> default: "false"</dt>
<dd>
<p>If true, make the default value true for alwayslink attributes in objc_library and objc_import.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_python_disallow_native_rules"><code><a href="#flag--incompatible_python_disallow_native_rules">--[no]incompatible_python_disallow_native_rules</a></code> default: "false"</dt>
<dd>
<p>When true, an error occurs when using the builtin py_* rules; instead the rule_python rules should be used. See https://github.com/bazelbuild/bazel/issues/17773 for more information and migration instructions.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Options that govern the behavior of the test environment or test runner:
<dt id="flag--allow_analysis_failures"><code><a href="#flag--allow_analysis_failures">--[no]allow_analysis_failures</a></code> default: "false"</dt>
<dd>
<p>If true, an analysis failure of a rule target results in the target's propagation
of an instance of <code>AnalysisFailureInfo</code> containing the error description, instead
of resulting in a build failure.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--analysis_testing_deps_limit"><code><a href="#flag--analysis_testing_deps_limit">--analysis_testing_deps_limit</a>=&lt;an integer&gt;</code> default: "2000"</dt>
<dd>
<p>Sets the maximum number of transitive dependencies through a rule attribute with
a <code>for_analysis_testing</code> configuration transition.
Exceeding this limit will result in a rule error.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--break_build_on_parallel_dex2oat_failure"><code><a href="#flag--break_build_on_parallel_dex2oat_failure">--[no]break_build_on_parallel_dex2oat_failure</a></code> default: "false"</dt>
<dd>
<p>If true dex2oat action failures will cause the build to break instead of executing dex2oat during test runtime.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--default_test_resources"><code><a href="#flag--default_test_resources">--default_test_resources</a>=&lt;a resource name followed by equal and 1 float or 4 float, e.g memory=10,30,60,100&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Override the default resources amount for tests. The expected format is
<code>{resource}={value}</code>. If a single positive number is specified as <code>{value}</code>
it will override the default resources for all test sizes. If 4
comma-separated numbers are specified, they will override the resource
amount for respectively the <code>small</code>, <code>medium</code>, <code>large</code>, <code>enormous</code> test sizes.
Values can also be <code>HOST_RAM</code>/<code>HOST_CPU</code>, optionally followed
by <code>[-|*]{float}</code> (eg. <code>memory=HOST_RAM*.1,HOST_RAM*.2,HOST_RAM*.3,HOST_RAM*.4</code>).
The default test resources specified by this flag are overridden by explicit
resources specified in tags.</p>
</dd>
<dt id="flag--experimental_android_use_parallel_dex2oat"><code><a href="#flag--experimental_android_use_parallel_dex2oat">--[no]experimental_android_use_parallel_dex2oat</a></code> default: "false"</dt>
<dd>
<p>Use dex2oat in parallel to possibly speed up android_test.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--ios_memleaks"><code><a href="#flag--ios_memleaks">--[no]ios_memleaks</a></code> default: "false"</dt>
<dd>
<p>Enable checking for memory leaks in ios_test targets.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>
</p></dd>
<dt id="flag--ios_simulator_device"><code><a href="#flag--ios_simulator_device">--ios_simulator_device</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>The device to simulate when running an iOS application in the simulator, e.g. 'iPhone 6'. You can get a list of devices by running 'xcrun simctl list devicetypes' on the machine the simulator will be run on.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
<dt id="flag--ios_simulator_version"><code><a href="#flag--ios_simulator_version">--ios_simulator_version</a>=&lt;a dotted version (for example &#39;2.3&#39; or &#39;3.3alpha2.4&#39;)&gt;</code> default: see description</dt>
<dd>
<p>The version of iOS to run on the simulator when running or testing. This is ignored for ios_test rules if a target device is specified in the rule.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
<dt id="flag--runs_per_test"><code><a href="#flag--runs_per_test">--runs_per_test</a>=&lt;a positive integer or test_regex@runs. This flag may be passed more than once&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies number of times to run each test. If any of those attempts fail for any
reason, the whole test is considered failed. Normally the value specified is
just an integer.</p>
<p>Example: <code>--runs_per_test=3</code> will run all tests 3 times.</p>
<p>Alternate syntax: <code>regex_filter@runs_per_test</code>. Where <code>runs_per_test</code> stands for
an integer value and <code>regex_filter</code> stands for a list of include and exclude
regular expression patterns (Also see --instrumentation_filter).</p>
<p>Example: <code>--runs_per_test=//foo/.*,-//foo/bar/.*@3</code> runs all tests in <code>//foo/</code> except
those under <code>//foo/bar</code> three times. This option can be passed multiple times. The most
recently passed argument that matches takes precedence. If nothing matches,
the test is only run once.</p>
</dd>
<dt id="flag--test_env"><code><a href="#flag--test_env">--test_env</a>=&lt;a &#39;name[=value]&#39; assignment with an optional value part or the special syntax &#39;=name&#39; to unset a variable&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies additional environment variables to be injected into the test runner
environment. Variables can be either specified by <code>name</code>, in which
case its value will be read from the Bazel client environment, or by the
<code>name=value</code> pair.
Previously set variables can be unset via <code>=name</code>.
This option can be used multiple times to specify several variables.
Used only by the 'bazel test' command.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
<dt id="flag--test_timeout"><code><a href="#flag--test_timeout">--test_timeout</a>=&lt;a single integer or comma-separated list of 4 integers&gt;</code> default: "-1"</dt>
<dd>
<p>Override the default test timeout values for test timeouts (in secs). If a single
positive integer value is specified it will override all categories.  If 4
comma-separated integers are specified, they will override the timeouts for
<code>short</code>, <code>moderate</code>, <code>long</code> and <code>eternal</code> (in that order). In either form, a value of
-1 tells blaze to use its default timeouts for that category.</p>
</dd>
<dt id="flag--zip_undeclared_test_outputs"><code><a href="#flag--zip_undeclared_test_outputs">--[no]zip_undeclared_test_outputs</a></code> default: "false"</dt>
<dd>
<p>If true, undeclared test outputs will be archived in a zip file.</p>
<p>Tags:
<a href="#effect_tag_TEST_RUNNER"><code>test_runner</code></a>
</p></dd>
</dl>
<dl>Options that trigger optimizations of the build time:
<dt id="flag--cc_dotd_files"><code><a href="#flag--cc_dotd_files">--[no]cc_dotd_files</a></code> default: "true"</dt>
<dd>
<p>Whether to generate and analyze .d files.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>
</p></dd>
<dt id="flag--cc_include_scanning"><code><a href="#flag--cc_include_scanning">--[no]cc_include_scanning</a></code> default: "false"</dt>
<dd>
<p>Whether to narrow inputs to C/C++ compilation by parsing #include lines from input files. This can improve performance and incrementality by decreasing the size of compilation input trees. However, it can also break builds because the include scanner does not fully implement C preprocessor semantics. In particular, it does not understand dynamic #include directives and ignores preprocessor conditional logic. Use at your own risk. Any issues relating to this flag that are filed will be closed. At Google without this flag your build will most likely fail.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_filter_library_jar_with_program_jar"><code><a href="#flag--experimental_filter_library_jar_with_program_jar">--[no]experimental_filter_library_jar_with_program_jar</a></code> default: "false"</dt>
<dd>
<p>Filter the ProGuard ProgramJar to remove any classes also present in the LibraryJar.</p>
<p>Tags:
<a href="#effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_inmemory_dotd_files"><code><a href="#flag--experimental_inmemory_dotd_files">--[no]experimental_inmemory_dotd_files</a></code> default: "true"</dt>
<dd>
<p>If enabled, C++ .d files will be passed through in memory directly from the remote build nodes instead of being written to disk.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_inmemory_jdeps_files"><code><a href="#flag--experimental_inmemory_jdeps_files">--[no]experimental_inmemory_jdeps_files</a></code> default: "true"</dt>
<dd>
<p>If enabled, the dependency (.jdeps) files generated from Java compilations will be passed through in memory directly from the remote build nodes instead of being written to disk.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_retain_test_configuration_across_testonly"><code><a href="#flag--experimental_retain_test_configuration_across_testonly">--[no]experimental_retain_test_configuration_across_testonly</a></code> default: "false"</dt>
<dd>
<p>When enabled, <code>--trim_test_configuration</code> will not trim the test configuration for rules
marked testonly=1. This is meant to reduce action conflict issues when non-test
rules depend on <code>cc_test</code> rules. No effect if <code>--trim_test_configuration</code> is
false.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_unsupported_and_brittle_include_scanning"><code><a href="#flag--experimental_unsupported_and_brittle_include_scanning">--[no]experimental_unsupported_and_brittle_include_scanning</a></code> default: "false"</dt>
<dd>
<p>Whether to narrow inputs to C/C++ compilation by parsing #include lines from input files. This can improve performance and incrementality by decreasing the size of compilation input trees. However, it can also break builds because the include scanner does not fully implement C preprocessor semantics. In particular, it does not understand dynamic #include directives and ignores preprocessor conditional logic. Use at your own risk. Any issues relating to this flag that are filed will be closed. At Google without this flag your build will most likely fail.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>, <a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--incremental_dexing"><code><a href="#flag--incremental_dexing">--[no]incremental_dexing</a></code> default: "true"</dt>
<dd>
<p>Does most of the work for dexing separately for each Jar file.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
<dt id="flag--objc_use_dotd_pruning"><code><a href="#flag--objc_use_dotd_pruning">--[no]objc_use_dotd_pruning</a></code> default: "true"</dt>
<dd>
<p>If set, .d files emitted by clang will be used to prune the set of inputs passed into objc compiles.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--process_headers_in_dependencies"><code><a href="#flag--process_headers_in_dependencies">--[no]process_headers_in_dependencies</a></code> default: "false"</dt>
<dd>
<p>When building a target //a:a, process headers in all targets that //a:a depends on (if header processing is enabled for the toolchain).</p>
<p>Tags:
<a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
<dt id="flag--trim_test_configuration"><code><a href="#flag--trim_test_configuration">--[no]trim_test_configuration</a></code> default: "true"</dt>
<dd>
<p>When enabled, test-related options will be cleared below the top level of the build. When this flag is active, tests cannot be built as dependencies of non-test rules, but changes to test-related options will not cause non-test rules to be re-analyzed.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></a>
</p></dd>
</dl>
<dl>Options that affect the verbosity, format or location of logging:
<dt id="flag--toolchain_resolution_debug"><code><a href="#flag--toolchain_resolution_debug">--toolchain_resolution_debug</a>=&lt;a comma-separated list of regex expressions with prefix &#39;-&#39; specifying excluded paths&gt;</code> default: "-.*"</dt>
<dd>
<p>Print debug information during toolchain resolution. The flag takes a regex, which is checked against toolchain types and specific targets to see which to debug. Multiple regexes may be  separated by commas, and then each regex is checked separately. Note: The output of this flag is very complex and will likely only be useful to experts in toolchain resolution.</p>
<p>Tags:
<a href="#effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></a>
</p></dd>
<dt id="flag--verbose_visibility_errors"><code><a href="#flag--verbose_visibility_errors">--[no]verbose_visibility_errors</a></code> default: "false"</dt>
<dd>
<p>If enabled, visibility errors include additional diagnostic information.</p>
<p>Tags:
<a href="#effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
</dl>
<dl>Options specifying or altering a generic input to a Bazel command that does not fall into other categories.:
<dt id="flag--flag_alias"><code><a href="#flag--flag_alias">--flag_alias</a>=&lt;a &#39;name=value&#39; flag alias&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Sets a shorthand name for a Starlark flag. It takes a single key-value pair in the form
<code>{key}={value}</code> as an argument.</p>
<p>Tags:
<a href="#effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></a>, <a href="#metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></a>
</p></dd>
<dt id="flag--incompatible_default_to_explicit_init_py"><code><a href="#flag--incompatible_default_to_explicit_init_py">--[no]incompatible_default_to_explicit_init_py</a></code> default: "false"</dt>
<dd>
<p>This flag changes the default behavior so that <strong>init</strong>.py files are no longer automatically created in the runfiles of Python targets. Precisely, when a py_binary or py_test target has legacy_create_init set to &quot;auto&quot; (the default), it is treated as false if and only if this flag is set. See https://github.com/bazelbuild/bazel/issues/10076.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
</dl>
<dl>Miscellaneous options, not otherwise categorized.:
<dt id="flag--cache_test_results"><code><a href="#flag--cache_test_results">--[no]cache_test_results</a></code> [<code>-t</code>] default: "auto"</dt>
<dd>
<p>If set to <code>auto</code>, Bazel reruns a test if and only if:</p>
<ol>
<li>Bazel detects changes in the test or its dependencies,</li>
<li>The test is marked as <code>external</code>,</li>
<li>Multiple test runs were requested with <code>--runs_per_test</code>, or</li>
<li>The test previously failed.
If set to <code>yes</code>, Bazel caches all test results except for tests marked as
<code>external</code>. If set to <code>no</code>, Bazel does not cache any test results.</li>
</ol>
</dd>
<dt id="flag--experimental_cancel_concurrent_tests"><code><a href="#flag--experimental_cancel_concurrent_tests">--[no]experimental_cancel_concurrent_tests</a></code> default: "never"</dt>
<dd>
<p>If <code>on_failed</code> or <code>on_passed</code>, then Blaze will cancel concurrently running tests on the first
successful run with that result. This is only useful in combination with
<code>--runs_per_test_detects_flakes</code>.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_fetch_all_coverage_outputs"><code><a href="#flag--experimental_fetch_all_coverage_outputs">--[no]experimental_fetch_all_coverage_outputs</a></code> default: "false"</dt>
<dd>
<p>If true, then Bazel fetches the entire coverage data directory for each test during a coverage run.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_generate_llvm_lcov"><code><a href="#flag--experimental_generate_llvm_lcov">--[no]experimental_generate_llvm_lcov</a></code> default: "false"</dt>
<dd>
<p>If true, coverage for clang will generate an LCOV report.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--experimental_java_classpath"><code><a href="#flag--experimental_java_classpath">--experimental_java_classpath</a>=&lt;off, javabuilder, bazel or bazel_no_fallback&gt;</code> default: "bazel"</dt>
<dd>
<p>Enables reduced classpaths for Java compilations.</p>
</dd>
<dt id="flag--experimental_run_android_lint_on_java_rules"><code><a href="#flag--experimental_run_android_lint_on_java_rules">--[no]experimental_run_android_lint_on_java_rules</a></code> default: "false"</dt>
<dd>
<p>Whether to validate java_* sources.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#metadata_tag_EXPERIMENTAL"><code>experimental</code></a>
</p></dd>
<dt id="flag--explicit_java_test_deps"><code><a href="#flag--explicit_java_test_deps">--[no]explicit_java_test_deps</a></code> default: "false"</dt>
<dd>
<p>Explicitly specify a dependency to JUnit or Hamcrest in a java_test instead of  accidentally obtaining from the TestRunner's deps. Only works for bazel right now.</p>
</dd>
<dt id="flag--host_java_launcher"><code><a href="#flag--host_java_launcher">--host_java_launcher</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The Java launcher used by tools that are executed during a build.</p>
</dd>
<dt id="flag--host_javacopt"><code><a href="#flag--host_javacopt">--host_javacopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to javac when building tools that are executed during a build.</p>
</dd>
<dt id="flag--host_jvmopt"><code><a href="#flag--host_jvmopt">--host_jvmopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the Java VM when building tools that are executed during  the build. These options will get added to the VM startup options of each  java_binary target.</p>
</dd>
<dt id="flag--incompatible_check_sharding_support"><code><a href="#flag--incompatible_check_sharding_support">--[no]incompatible_check_sharding_support</a></code> default: "true"</dt>
<dd>
<p>If true, Bazel will fail a sharded test if the test runner does not indicate that it
supports sharding by touching the file at the path in <code>TEST_SHARD_STATUS_FILE</code>.
If false, a test runner that does not support sharding will lead to all tests
running in each shard.</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_exclusive_test_sandboxed"><code><a href="#flag--incompatible_exclusive_test_sandboxed">--[no]incompatible_exclusive_test_sandboxed</a></code> default: "true"</dt>
<dd>
<p>If true, exclusive tests will run with sandboxed strategy. Add <code>local</code> tag to force
an exclusive test run locally</p>
<p>Tags:
<a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--incompatible_strict_action_env"><code><a href="#flag--incompatible_strict_action_env">--[no]incompatible_strict_action_env</a></code> default: "false"</dt>
<dd>
<p>If true, Bazel uses an environment with a static value for PATH and does not
inherit <code>LD_LIBRARY_PATH</code>. Use <code>--action_env=ENV_VARIABLE</code> if you want to
inherit specific environment variables from the client, but note that doing so
can prevent cross-user caching if a shared cache is used.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>, <a href="#metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></a>
</p></dd>
<dt id="flag--j2objc_translation_flags"><code><a href="#flag--j2objc_translation_flags">--j2objc_translation_flags</a>=&lt;comma-separated list of options&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the J2ObjC tool.</p>
</dd>
<dt id="flag--java_debug"><code><a href="#flag--java_debug">--java_debug</a></code></dt>
<dd>
<p>Causes the Java virtual machine of a java test to wait for a connection from a JDWP-compliant debugger (such as jdb) before starting the test. Implies -test_output=streamed.</p>
<p>Expands to:
<br/>&nbsp;&nbsp;<code><a href="#flag--test_arg">--test_arg=--wrapper_script_flag=--debug</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--test_output">--test_output=streamed</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--test_strategy">--test_strategy=exclusive</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--test_timeout">--test_timeout=9999</a></code>
<br/>&nbsp;&nbsp;<code><a href="#flag--nocache_test_results">--nocache_test_results</a></code>
</p></dd>
<dt id="flag--java_deps"><code><a href="#flag--java_deps">--[no]java_deps</a></code> default: "true"</dt>
<dd>
<p>Generate dependency information (for now, compile-time classpath) per Java target.</p>
</dd>
<dt id="flag--java_header_compilation"><code><a href="#flag--java_header_compilation">--[no]java_header_compilation</a></code> default: "true"</dt>
<dd>
<p>Compile ijars directly from source.</p>
</dd>
<dt id="flag--java_language_version"><code><a href="#flag--java_language_version">--java_language_version</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The Java language version</p>
</dd>
<dt id="flag--java_launcher"><code><a href="#flag--java_launcher">--java_launcher</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The Java launcher to use when building Java binaries.  If this flag is set to the empty string, the JDK launcher is used. The &quot;launcher&quot; attribute overrides this flag.</p>
</dd>
<dt id="flag--java_runtime_version"><code><a href="#flag--java_runtime_version">--java_runtime_version</a>=&lt;a string&gt;</code> default: "local_jdk"</dt>
<dd>
<p>The Java runtime version</p>
</dd>
<dt id="flag--javacopt"><code><a href="#flag--javacopt">--javacopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to javac.</p>
</dd>
<dt id="flag--jvmopt"><code><a href="#flag--jvmopt">--jvmopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the Java VM. These options will get added to the VM startup options of each java_binary target.</p>
</dd>
<dt id="flag--legacy_main_dex_list_generator"><code><a href="#flag--legacy_main_dex_list_generator">--legacy_main_dex_list_generator</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies a binary to use to generate the list of classes that must be in the main dex when compiling legacy multidex.</p>
</dd>
<dt id="flag--optimizing_dexer"><code><a href="#flag--optimizing_dexer">--optimizing_dexer</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies a binary to use to do dexing without sharding.</p>
</dd>
<dt id="flag--plugin"><code><a href="#flag--plugin">--plugin</a>=&lt;a build target label&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Plugins to use in the build. Currently works with java_plugin.</p>
</dd>
<dt id="flag--proguard_top"><code><a href="#flag--proguard_top">--proguard_top</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>Specifies which version of ProGuard to use for code removal when building a Java binary.</p>
</dd>
<dt id="flag--proto_compiler"><code><a href="#flag--proto_compiler">--proto_compiler</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:protoc"</dt>
<dd>
<p>The label of the proto-compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_profile"><code><a href="#flag--proto_profile">--[no]proto_profile</a></code> default: "true"</dt>
<dd>
<p>Whether to pass profile_path to the proto compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_profile_path"><code><a href="#flag--proto_profile_path">--proto_profile_path</a>=&lt;a build target label&gt;</code> default: see description</dt>
<dd>
<p>The profile to pass to the proto compiler as profile_path. If unset, but  --proto_profile is true (the default), infers the path from --fdo_optimize.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_cc"><code><a href="#flag--proto_toolchain_for_cc">--proto_toolchain_for_cc</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:cc_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile C++ protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_j2objc"><code><a href="#flag--proto_toolchain_for_j2objc">--proto_toolchain_for_j2objc</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/j2objc:j2objc_proto_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile j2objc protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_java"><code><a href="#flag--proto_toolchain_for_java">--proto_toolchain_for_java</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:java_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile Java protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--proto_toolchain_for_javalite"><code><a href="#flag--proto_toolchain_for_javalite">--proto_toolchain_for_javalite</a>=&lt;a build target label&gt;</code> default: "@bazel_tools//tools/proto:javalite_toolchain"</dt>
<dd>
<p>Label of proto_lang_toolchain() which describes how to compile JavaLite protos</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--protocopt"><code><a href="#flag--protocopt">--protocopt</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Additional options to pass to the protobuf compiler.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>
</p></dd>
<dt id="flag--runs_per_test_detects_flakes"><code><a href="#flag--runs_per_test_detects_flakes">--[no]runs_per_test_detects_flakes</a></code> default: "false"</dt>
<dd>
<p>If true, any shard in which at least one run/attempt passes and at least one run/attempt fails gets a FLAKY status.</p>
</dd>
<dt id="flag--shell_executable"><code><a href="#flag--shell_executable">--shell_executable</a>=&lt;a path&gt;</code> default: see description</dt>
<dd>
<p>Absolute path to the shell executable for Bazel to use. If this is unset, but the
<code>BAZEL_SH</code> environment variable is set on the first Bazel invocation (that starts
up a Bazel server), Bazel uses that. If neither is set, Bazel uses a hard-coded
default path depending on the operating system it runs on;</p>
<ul>
<li>Windows: <code>c:/msys64/usr/bin/bash.exe</code></li>
<li>FreeBSD: <code>/usr/local/bin/bash</code></li>
<li>All others: <code>/bin/bash</code>.</li>
</ul>
<p>Note that using a shell that is not compatible with <code>bash</code> may lead
to build failures or runtime failures of the generated binaries.</p>
<p>Tags:
<a href="#effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></a>
</p></dd>
<dt id="flag--test_arg"><code><a href="#flag--test_arg">--test_arg</a>=&lt;a string&gt;</code> multiple uses are accumulated</dt>
<dd>
<p>Specifies additional options and arguments that should be passed to the test
executable. Can be used multiple times to specify several arguments.
If multiple tests are executed, each of them will receive identical arguments.
Used only by the <code>bazel test</code> command.</p>
</dd>
<dt id="flag--test_filter"><code><a href="#flag--test_filter">--test_filter</a>=&lt;a string&gt;</code> default: see description</dt>
<dd>
<p>Specifies a filter to forward to the test framework.  Used to limit the tests run. Note that this does not affect which targets are built.</p>
</dd>
<dt id="flag--test_result_expiration"><code><a href="#flag--test_result_expiration">--test_result_expiration</a>=&lt;an integer&gt;</code> default: "-1"</dt>
<dd>
<p>This option is deprecated and has no effect.</p>
</dd>
<dt id="flag--test_runner_fail_fast"><code><a href="#flag--test_runner_fail_fast">--[no]test_runner_fail_fast</a></code> default: "false"</dt>
<dd>
<p>Forwards fail fast option to the test runner. The test runner should stop execution upon first failure.</p>
</dd>
<dt id="flag--test_sharding_strategy"><code><a href="#flag--test_sharding_strategy">--test_sharding_strategy</a>=&lt;explicit, disabled or forced=k where k is the number of shards to enforce&gt;</code> default: "explicit"</dt>
<dd>
<p>Specify strategy for test sharding:</p>
<ul>
<li><code>explicit</code> to only use sharding if the <code>shard_count</code> <code>BUILD</code> attribute is
present.</li>
<li><code>disabled</code> to never use test sharding.</li>
<li><code>forced=k</code> to enforce <code>k</code> shards for testing regardless of the <code>shard_count</code> <code>BUILD</code>
attribute.</li>
</ul>
</dd>
<dt id="flag--tool_java_language_version"><code><a href="#flag--tool_java_language_version">--tool_java_language_version</a>=&lt;a string&gt;</code> default: ""</dt>
<dd>
<p>The Java language version used to execute the tools that are needed during a build</p>
</dd>
<dt id="flag--tool_java_runtime_version"><code><a href="#flag--tool_java_runtime_version">--tool_java_runtime_version</a>=&lt;a string&gt;</code> default: "remotejdk_11"</dt>
<dd>
<p>The Java runtime version used to execute tools during the build</p>
</dd>
<dt id="flag--use_ijars"><code><a href="#flag--use_ijars">--[no]use_ijars</a></code> default: "true"</dt>
<dd>
<p>If enabled, this option causes Java compilation to use interface jars. This will result in faster incremental compilation, but error messages can be different.</p>
</dd>
</dl>

<h2><a name="version">Version Options</a></h2>
<dl>Options that let the user configure the intended output, affecting its value, as opposed to its existence:
<dt id="version-flag--gnu_format"><code id="gnu_format"><a href="#version-flag--gnu_format">--[no]gnu_format</a></code> default: "false"</dt>
<dd>
<p>If set, write the version to stdout using the conventions described in the GNU standards.</p>
<p>Tags:
<a href="#effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></a>, <a href="#effect_tag_EXECUTION"><code>execution</code></a>
</p></dd>
</dl>

<h3>Option Effect Tags</h3>
<table>
<tr>
<td id="effect_tag_UNKNOWN"><code>unknown</code></td>
<td>This option has unknown, or undocumented, effect.</td>
</tr>
<tr>
<td id="effect_tag_NO_OP"><code>no_op</code></td>
<td>This option has literally no effect.</td>
</tr>
<tr>
<td id="effect_tag_LOSES_INCREMENTAL_STATE"><code>loses_incremental_state</code></td>
<td>Changing the value of this option can cause significant loss of incremental state, which slows builds. State could be lost due to a server restart or to invalidation of a large part of the dependency graph.</td>
</tr>
<tr>
<td id="effect_tag_CHANGES_INPUTS"><code>changes_inputs</code></td>
<td>This option actively changes the inputs that bazel considers for the build, such as filesystem restrictions, repository versions, or other options.</td>
</tr>
<tr>
<td id="effect_tag_AFFECTS_OUTPUTS"><code>affects_outputs</code></td>
<td>This option affects bazel&#39;s outputs. This tag is intentionally broad, can include transitive affects, and does not specify the type of output it affects.</td>
</tr>
<tr>
<td id="effect_tag_BUILD_FILE_SEMANTICS"><code>build_file_semantics</code></td>
<td>This option affects the semantics of BUILD or .bzl files.</td>
</tr>
<tr>
<td id="effect_tag_BAZEL_INTERNAL_CONFIGURATION"><code>bazel_internal_configuration</code></td>
<td>This option affects settings of bazel-internal machinery. This tag does not, on its own, mean that build artifacts are affected.</td>
</tr>
<tr>
<td id="effect_tag_LOADING_AND_ANALYSIS"><code>loading_and_analysis</code></td>
<td>This option affects the loading and analysis of dependencies, and the building of the dependency graph.</td>
</tr>
<tr>
<td id="effect_tag_EXECUTION"><code>execution</code></td>
<td>This option affects the execution phase, such as sandboxing or remote execution related options.</td>
</tr>
<tr>
<td id="effect_tag_HOST_MACHINE_RESOURCE_OPTIMIZATIONS"><code>host_machine_resource_optimizations</code></td>
<td>This option triggers an optimization that may be machine specific and is not guaranteed to work on all machines. The optimization could include a tradeoff with other aspects of performance, such as memory or cpu cost.</td>
</tr>
<tr>
<td id="effect_tag_EAGERNESS_TO_EXIT"><code>eagerness_to_exit</code></td>
<td>This option changes how eagerly bazel will exit from a failure, where a choice between continuing despite the failure and ending the invocation exists.</td>
</tr>
<tr>
<td id="effect_tag_BAZEL_MONITORING"><code>bazel_monitoring</code></td>
<td>This option is used to monitor bazel&#39;s behavior and performance.</td>
</tr>
<tr>
<td id="effect_tag_TERMINAL_OUTPUT"><code>terminal_output</code></td>
<td>This option affects bazel&#39;s terminal output.</td>
</tr>
<tr>
<td id="effect_tag_ACTION_COMMAND_LINES"><code>action_command_lines</code></td>
<td>This option changes the command line arguments of one or more build actions.</td>
</tr>
<tr>
<td id="effect_tag_TEST_RUNNER"><code>test_runner</code></td>
<td>This option changes the testrunner environment of the build.</td>
</tr>
</table>
<h3>Option Metadata Tags</h3>
<table>
<tr>
<td id="metadata_tag_EXPERIMENTAL"><code>experimental</code></td>
<td>This option triggers an experimental feature with no guarantees of functionality.</td>
</tr>
<tr>
<td id="metadata_tag_INCOMPATIBLE_CHANGE"><code>incompatible_change</code></td>
<td>This option triggers a breaking change. Use this option to test your migration readiness or get early access to the new feature</td>
</tr>
<tr>
<td id="metadata_tag_DEPRECATED"><code>deprecated</code></td>
<td>This option is deprecated. It might be that the feature it affects is deprecated, or that another method of supplying the information is preferred.</td>
</tr>
<tr>
<td id="metadata_tag_NON_CONFIGURABLE"><code>non_configurable</code></td>
<td>This option cannot be changed in a transition or be used in a select() statement.</td>
</tr>
</table>

<br/><br/><br/><br/>
</body>
</html>
