docs/CommandGuide/lli.rst

   1 lli - directly execute programs from LLVM bitcode
   2 =================================================
   3
   4 SYNOPSIS
   5 --------
   6
   7 :program:`lli` [*options*] [*filename*] [*program args*]
   8
   9 DESCRIPTION
  10 -----------
  11
  12 :program:`lli` directly executes programs in LLVM bitcode format.  It takes a program
  13 in LLVM bitcode format and executes it using a just-in-time compiler or an
  14 interpreter.
  15
  16 :program:`lli` is *not* an emulator. It will not execute IR of different architectures
  17 and it can only interpret (or JIT-compile) for the host architecture.
  18
  19 The JIT compiler takes the same arguments as other tools, like :program:`llc`,
  20 but they don't necessarily work for the interpreter.
  21
  22 If `filename` is not specified, then :program:`lli` reads the LLVM bitcode for the
  23 program from standard input.
  24
  25 The optional *args* specified on the command line are passed to the program as
  26 arguments.
  27
  28 GENERAL OPTIONS
  29 ---------------
  30
  31 .. option:: -fake-argv0=executable
  32
  33  Override the ``argv[0]`` value passed into the executing program.
  34
  35 .. option:: -force-interpreter={false,true}
  36
  37  If set to true, use the interpreter even if a just-in-time compiler is available
  38  for this architecture. Defaults to false.
  39
  40 .. option:: -help
  41
  42  Print a summary of command line options.
  43
  44 .. option:: -load=pluginfilename
  45
  46  Causes :program:`lli` to load the plugin (shared object) named *pluginfilename* and use
  47  it for optimization.
  48
  49 .. option:: -stats
  50
  51  Print statistics from the code-generation passes. This is only meaningful for
  52  the just-in-time compiler, at present.
  53
  54 .. option:: -time-passes
  55
  56  Record the amount of time needed for each code-generation pass and print it to
  57  standard error.
  58
  59 .. option:: -version
  60
  61  Print out the version of :program:`lli` and exit without doing anything else.
  62
  63 TARGET OPTIONS
  64 --------------
  65
  66 .. option:: -mtriple=target triple
  67
  68  Override the target triple specified in the input bitcode file with the
  69  specified string.  This may result in a crash if you pick an
  70  architecture which is not compatible with the current system.
  71
  72 .. option:: -march=arch
  73
  74  Specify the architecture for which to generate assembly, overriding the target
  75  encoded in the bitcode file.  See the output of **llc -help** for a list of
  76  valid architectures.  By default this is inferred from the target triple or
  77  autodetected to the current architecture.
  78
  79 .. option:: -mcpu=cpuname
  80
  81  Specify a specific chip in the current architecture to generate code for.
  82  By default this is inferred from the target triple and autodetected to
  83  the current architecture.  For a list of available CPUs, use:
  84  **llvm-as < /dev/null | llc -march=xyz -mcpu=help**
  85
  86 .. option:: -mattr=a1,+a2,-a3,...
  87
  88  Override or control specific attributes of the target, such as whether SIMD
  89  operations are enabled or not.  The default set of attributes is set by the
  90  current CPU.  For a list of available attributes, use:
  91  **llvm-as < /dev/null | llc -march=xyz -mattr=help**
  92
  93 FLOATING POINT OPTIONS
  94 ----------------------
  95
  96 .. option:: -disable-excess-fp-precision
  97
  98  Disable optimizations that may increase floating point precision.
  99
 100 .. option:: -enable-no-infs-fp-math
 101
 102  Enable optimizations that assume no Inf values.
 103
 104 .. option:: -enable-no-nans-fp-math
 105
 106  Enable optimizations that assume no NAN values.
 107
 108 .. option:: -enable-unsafe-fp-math
 109
 110  Causes :program:`lli` to enable optimizations that may decrease floating point
 111  precision.
 112
 113 .. option:: -soft-float
 114
 115  Causes :program:`lli` to generate software floating point library calls instead of
 116  equivalent hardware instructions.
 117
 118 CODE GENERATION OPTIONS
 119 -----------------------
 120
 121 .. option:: -code-model=model
 122
 123  Choose the code model from:
 124
 125  .. code-block:: text
 126
 127       default: Target default code model
 128       tiny: Tiny code model
 129       small: Small code model
 130       kernel: Kernel code model
 131       medium: Medium code model
 132       large: Large code model
 133
 134 .. option:: -disable-post-RA-scheduler
 135
 136  Disable scheduling after register allocation.
 137
 138 .. option:: -disable-spill-fusing
 139
 140  Disable fusing of spill code into instructions.
 141
 142 .. option:: -jit-enable-eh
 143
 144  Exception handling should be enabled in the just-in-time compiler.
 145
 146 .. option:: -join-liveintervals
 147
 148  Coalesce copies (default=true).
 149
 150 .. option:: -nozero-initialized-in-bss
 151
 152   Don't place zero-initialized symbols into the BSS section.
 153
 154 .. option:: -pre-RA-sched=scheduler
 155
 156  Instruction schedulers available (before register allocation):
 157
 158  .. code-block:: text
 159
 160       =default: Best scheduler for the target
 161       =none: No scheduling: breadth first sequencing
 162       =simple: Simple two pass scheduling: minimize critical path and maximize processor utilization
 163       =simple-noitin: Simple two pass scheduling: Same as simple except using generic latency
 164       =list-burr: Bottom-up register reduction list scheduling
 165       =list-tdrr: Top-down register reduction list scheduling
 166       =list-td: Top-down list scheduler -print-machineinstrs - Print generated machine code
 167
 168 .. option:: -regalloc=allocator
 169
 170  Register allocator to use (default=linearscan)
 171
 172  .. code-block:: text
 173
 174       =bigblock: Big-block register allocator
 175       =linearscan: linear scan register allocator =local -   local register allocator
 176       =simple: simple register allocator
 177
 178 .. option:: -relocation-model=model
 179
 180  Choose relocation model from:
 181
 182  .. code-block:: text
 183
 184       =default: Target default relocation model
 185       =static: Non-relocatable code =pic -   Fully relocatable, position independent code
 186       =dynamic-no-pic: Relocatable external references, non-relocatable code
 187
 188 .. option:: -spiller
 189
 190  Spiller to use (default=local)
 191
 192  .. code-block:: text
 193
 194       =simple: simple spiller
 195       =local: local spiller
 196
 197 .. option:: -x86-asm-syntax=syntax
 198
 199  Choose style of code to emit from X86 backend:
 200
 201  .. code-block:: text
 202
 203       =att: Emit AT&T-style assembly
 204       =intel: Emit Intel-style assembly
 205
 206 EXIT STATUS
 207 -----------
 208
 209 If :program:`lli` fails to load the program, it will exit with an exit code of 1.
 210 Otherwise, it will return the exit code of the program it executes.
 211
 212 SEE ALSO
 213 --------
 214
 215 :program:`llc`