
GraalVM native-image-configure tool

This tool can be used to prepare a configuration of JNI, reflection and
resources for a native-image build.

Usage: native-image-configure generate [options]
       native-image-configure generate-filters [options]
       native-image-configure command-file <command-file-path>
       native-image-configure help

generate                  generates configuration file(s) from all inputs.
    --trace-input=<path>
                          reads and processes a trace file at the given path.
    --input-dir=<path>
                          reads a set of configuration files from the directory
                          at the given path. This is equivalent to all of:
                           --reflect-input=<path>/reflect-config.json
                           --jni-input=<path>/jni-config.json
                           --proxy-input=<path>/proxy-config.json
                           --resource-input=<path>/resource-config.json
    --reflect-input=<path>
                          reads a reflection configuration file at <path>.
    --jni-input=<path>
                          reads a JNI configuration file at <path>.
    --proxy-input=<path>
                          reads a dynamic proxy configuration file at <path>.
    --resource-input=<path>
                          reads a resource configuration file at <path>.
    --output-dir=<path>
                          writes a set of configuration files to the directory
                          at the given path. Existing files are replaced. This
                          option is equivalent to all of:
                           --reflect-output=<path>/reflect-config.json
                           --jni-output=<path>/jni-config.json
                           --proxy-output=<path>/proxy-config.json
                           --resource-output=<path>/resource-config.json
    --reflect-output=<path>
                          write a reflection configuration file to <path>. This
                          file can be later provided to native-image with
                          -H:ReflectionConfigurationFiles=<path>.
    --jni-output=<path>
                          write a JNI configuration file to <path>. This file
                          can be later provided to native-image with
                          -H:JNIConfigurationFiles=<path>.
    --proxy-output=<path>
                          write a dynamic proxy configuration file to <path>.
                          This file can be later provided to native-image with
                          -H:DynamicProxyConfigurationFiles=<path>.
    --resource-output=<path>
                          write a configuration file containing used resources
                          (getResource) to <path>. This file can later be
                          provided to native-image with
                          -H:ResourceConfigurationFiles=<path>.
                          The paths in the configuration file might need to be
                          adjusted for the build directories/classpath.
    --caller-filter-file=<path>
                          Provides a custom filter file for excluding usages
                          of JNI, reflection and resources based on the caller
                          class (read more below). This option can be provided
                          more than once, and the filter rules from the files
                          will be processed in the specified order.
    --no-builtin-caller-filter
                          Usages of JNI, reflection and resources that are
                          internal to the JDK, to GraalVM or to the Java VM do
                          not need to be configured for native-image builds and
                          by default, are filtered (removed) from the generated
                          configurations. This option disables the built-in
                          filter for such usages based on the caller class.
    --no-builtin-heuristic-filter
                          This option disables builtin heuristics that identify
                          further internal JNI, reflection and resource usages.

generate-filters          builds a class filter according to the parameters.
                          Filter rules are created according to the order of
                          these parameters, and filter rules are applied in
                          their order so that the last matching one "wins", so
                          the order of the parameters is relevant. Filter files
                          can be used with the caller-filter-file option of
                          native-image-agent.
    --include-classes=<class-pattern>
                          adds a single rule to include a specific class, such
                          as "com.oracle.graal.Compiler", or classes matching a
                          specified pattern, for example "com.oracle.graal.*"
                          for classes directly in package "com.oracle.graal",
                          or "com.oracle.graal.** (double asterisks) for all
                          classes in "com.oracle.graal" AND all of its
                          subpackages and their subpackages, recursively. The
                          rule can potentially override rules from preceding
                          parameters. Can be specified several times.
    --exclude-classes=<class-pattern>
                          adds a single rule to exclude classes matching the
                          specified pattern, potentially overriding rules from
                          preceding parameters. Can be specified several times.
    --input-file=<path>
                          reads a file with filter rules from the given path.
                          Rules are processed in the order in which they occur
                          in the file, so that subsequent rules potentially
                          override preceding rules, including those from the
                          --include and --exclude parameters. Can be specified
                          several times.
    --output-file=<path>
                          specifies a file to which the output file is written.
                          If this parameter is not provided, the filter is
                          written to standard output.

help                      prints this help message.

command-file              reads the command-line arguments from the given file.
                          The command-file contains one argument per line, with
                          no quoting of whitespace necessary (newline
                          characters in an argument cannot be represented).
                          An example command file:
                          generate
                          --input-dir=input-dir-1-path
                          --input-dir=input-dir-2-path
                          --output-dir=output-dir-path
                          This option is meant for executing commands with
                          an argument list that is too large to be passed by
                          regular means, which might be generated by other
                          tools.
    <command-file-path>
                          specifies the path to a command file
