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:: perl
 126
 127       default: Target default code model
 128       small: Small code model
 129       kernel: Kernel code model
 130       medium: Medium code model
 131       large: Large code model
 132
 133 .. option:: -disable-post-RA-scheduler
 134
 135  Disable scheduling after register allocation.
 136
 137 .. option:: -disable-spill-fusing
 138
 139  Disable fusing of spill code into instructions.
 140
 141 .. option:: -jit-enable-eh
 142
 143  Exception handling should be enabled in the just-in-time compiler.
 144
 145 .. option:: -join-liveintervals
 146
 147  Coalesce copies (default=true).
 148
 149 .. option:: -nozero-initialized-in-bss
 150
 151   Don't place zero-initialized symbols into the BSS section.
 152
 153 .. option:: -pre-RA-sched=scheduler
 154
 155  Instruction schedulers available (before register allocation):
 156
 157  .. code-block:: perl
 158
 159       =default: Best scheduler for the target
 160       =none: No scheduling: breadth first sequencing
 161       =simple: Simple two pass scheduling: minimize critical path and maximize processor utilization
 162       =simple-noitin: Simple two pass scheduling: Same as simple except using generic latency
 163       =list-burr: Bottom-up register reduction list scheduling
 164       =list-tdrr: Top-down register reduction list scheduling
 165       =list-td: Top-down list scheduler -print-machineinstrs - Print generated machine code
 166
 167 .. option:: -regalloc=allocator
 168
 169  Register allocator to use (default=linearscan)
 170
 171  .. code-block:: perl
 172
 173       =bigblock: Big-block register allocator
 174       =linearscan: linear scan register allocator =local -   local register allocator
 175       =simple: simple register allocator
 176
 177 .. option:: -relocation-model=model
 178
 179  Choose relocation model from:
 180
 181  .. code-block:: perl
 182
 183       =default: Target default relocation model
 184       =static: Non-relocatable code =pic -   Fully relocatable, position independent code
 185       =dynamic-no-pic: Relocatable external references, non-relocatable code
 186
 187 .. option:: -spiller
 188
 189  Spiller to use (default=local)
 190
 191  .. code-block:: perl
 192
 193       =simple: simple spiller
 194       =local: local spiller
 195
 196 .. option:: -x86-asm-syntax=syntax
 197
 198  Choose style of code to emit from X86 backend:
 199
 200  .. code-block:: perl
 201
 202       =att: Emit AT&T-style assembly
 203       =intel: Emit Intel-style assembly
 204
 205 EXIT STATUS
 206 -----------
 207
 208 If :program:`lli` fails to load the program, it will exit with an exit code of 1.
 209 Otherwise, it will return the exit code of the program it executes.
 210
 211 SEE ALSO
 212 --------
 213
 214 :program:`llc`