Mark math lib intrinsics readonly, on the grounds
[oota-llvm.git] / include / llvm / Intrinsics.td
1 //===- Intrinsics.td - Defines all LLVM intrinsics ---------*- tablegen -*-===//
2 // 
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 // 
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines properties of all LLVM intrinsics.
11 //
12 //===----------------------------------------------------------------------===//
13
14 include "llvm/CodeGen/ValueTypes.td"
15
16 //===----------------------------------------------------------------------===//
17 //  Properties we keep track of for intrinsics.
18 //===----------------------------------------------------------------------===//
19
20 class IntrinsicProperty;
21
22 // Intr*Mem - Memory properties.  An intrinsic is allowed to have exactly one of
23 // these properties set.  They are listed from the most aggressive (best to use
24 // if correct) to the least aggressive.  If no property is set, the worst case 
25 // is assumed (IntrWriteMem).
26
27 // IntrNoMem - The intrinsic does not access memory or have any other side
28 // effects.  It may be CSE'd deleted if dead, etc.
29 def IntrNoMem : IntrinsicProperty;
30
31 // IntrReadArgMem - This intrinsic reads only from memory that one of its
32 // arguments points to, but may read an unspecified amount.
33 def IntrReadArgMem : IntrinsicProperty;
34
35 // IntrReadMem - This intrinsic reads from unspecified memory, so it cannot be
36 // moved across stores.  However, it can be reordered otherwise and can be
37 // deleted if dead.
38 def IntrReadMem : IntrinsicProperty;
39
40 // IntrWriteArgMem - This intrinsic reads and writes only from memory that one
41 // of its arguments points to, but may access an unspecified amount.  It has no
42 // other side effects.  This may only be used if the intrinsic doesn't "capture"
43 // the argument pointer (e.g. storing it someplace).
44 def IntrWriteArgMem : IntrinsicProperty;
45
46 // IntrWriteMem - This intrinsic may read or modify unspecified memory or has 
47 // other side effects.  It cannot be modified by the optimizer.  This is the
48 // default if the intrinsic has no other Intr*Mem property.
49 def IntrWriteMem : IntrinsicProperty;
50
51 // Commutative - This intrinsic is commutative: X op Y == Y op X.
52 def Commutative : IntrinsicProperty;
53
54 //===----------------------------------------------------------------------===//
55 // Types used by intrinsics.
56 //===----------------------------------------------------------------------===//
57
58 class LLVMType<ValueType vt> {
59   ValueType VT = vt;
60 }
61
62 class LLVMPointerType<LLVMType elty>
63   : LLVMType<iPTR>{
64   LLVMType ElTy = elty;
65
66
67 class LLVMAnyPointerType<LLVMType elty>
68   : LLVMType<iPTRAny>{
69   LLVMType ElTy = elty;
70
71
72 class LLVMMatchType<int num>
73   : LLVMType<OtherVT>{
74   int Number = num;
75 }
76
77 def llvm_void_ty       : LLVMType<isVoid>;
78 def llvm_anyint_ty     : LLVMType<iAny>;
79 def llvm_anyfloat_ty   : LLVMType<fAny>;
80 def llvm_i1_ty         : LLVMType<i1>;
81 def llvm_i8_ty         : LLVMType<i8>;
82 def llvm_i16_ty        : LLVMType<i16>;
83 def llvm_i32_ty        : LLVMType<i32>;
84 def llvm_i64_ty        : LLVMType<i64>;
85 def llvm_float_ty      : LLVMType<f32>;
86 def llvm_double_ty     : LLVMType<f64>;
87 def llvm_f80_ty        : LLVMType<f80>;
88 def llvm_f128_ty       : LLVMType<f128>;
89 def llvm_ppcf128_ty    : LLVMType<ppcf128>;
90 def llvm_ptr_ty        : LLVMPointerType<llvm_i8_ty>;             // i8*
91 def llvm_ptrptr_ty     : LLVMPointerType<llvm_ptr_ty>;            // i8**
92 def llvm_anyptr_ty     : LLVMPointerType<llvm_i8_ty>;             // (space)i8*
93 def llvm_empty_ty      : LLVMType<OtherVT>;                       // { }
94 def llvm_descriptor_ty : LLVMPointerType<llvm_empty_ty>;          // { }*
95
96 def llvm_v16i8_ty      : LLVMType<v16i8>;    // 16 x i8
97 def llvm_v8i16_ty      : LLVMType<v8i16>;    //  8 x i16
98 def llvm_v2i64_ty      : LLVMType<v2i64>;    //  2 x i64
99 def llvm_v2i32_ty      : LLVMType<v2i32>;    //  2 x i32
100 def llvm_v1i64_ty      : LLVMType<v1i64>;    //  1 x i64
101 def llvm_v4i32_ty      : LLVMType<v4i32>;    //  4 x i32
102 def llvm_v4f32_ty      : LLVMType<v4f32>;    //  4 x float
103 def llvm_v2f64_ty      : LLVMType<v2f64>;    //  2 x double
104
105 // MMX Vector Types
106 def llvm_v8i8_ty       : LLVMType<v8i8>;     //  8 x i8
107 def llvm_v4i16_ty      : LLVMType<v4i16>;    //  4 x i16
108
109 def llvm_vararg_ty     : LLVMType<isVoid>;   // this means vararg here
110
111 //===----------------------------------------------------------------------===//
112 // Intrinsic Definitions.
113 //===----------------------------------------------------------------------===//
114
115 // Intrinsic class - This is used to define one LLVM intrinsic.  The name of the
116 // intrinsic definition should start with "int_", then match the LLVM intrinsic
117 // name with the "llvm." prefix removed, and all "."s turned into "_"s.  For
118 // example, llvm.bswap.i16 -> int_bswap_i16.
119 //
120 //  * Types is a list containing the return type and the argument types
121 //    expected for the intrinsic.
122 //  * Properties can be set to describe the behavior of the intrinsic.
123 //
124 class Intrinsic<list<LLVMType> types,
125                 list<IntrinsicProperty> properties = [],
126                 string name = ""> {
127   string LLVMName = name;
128   string TargetPrefix = "";   // Set to a prefix for target-specific intrinsics.
129   list<LLVMType> Types = types;
130   list<IntrinsicProperty> Properties = properties;
131 }
132
133 /// GCCBuiltin - If this intrinsic exactly corresponds to a GCC builtin, this
134 /// specifies the name of the builtin.  This provides automatic CBE and CFE
135 /// support.
136 class GCCBuiltin<string name> {
137   string GCCBuiltinName = name;
138 }
139
140
141 //===--------------- Variable Argument Handling Intrinsics ----------------===//
142 //  
143
144 def int_vastart : Intrinsic<[llvm_void_ty, llvm_ptr_ty], [], "llvm.va_start">;
145 def int_vacopy  : Intrinsic<[llvm_void_ty, llvm_ptr_ty, llvm_ptr_ty], [],
146                             "llvm.va_copy">;
147 def int_vaend   : Intrinsic<[llvm_void_ty, llvm_ptr_ty], [], "llvm.va_end">;
148
149 //===------------------- Garbage Collection Intrinsics --------------------===//
150 //  
151 def int_gcroot  : Intrinsic<[llvm_void_ty, llvm_ptrptr_ty, llvm_ptr_ty]>;
152 def int_gcread  : Intrinsic<[llvm_ptr_ty, llvm_ptr_ty, llvm_ptrptr_ty],
153                             [IntrReadArgMem]>;
154 def int_gcwrite : Intrinsic<[llvm_void_ty, llvm_ptr_ty, llvm_ptr_ty,
155                              llvm_ptrptr_ty], [IntrWriteArgMem]>;
156
157 //===--------------------- Code Generator Intrinsics ----------------------===//
158 //  
159 def int_returnaddress : Intrinsic<[llvm_ptr_ty, llvm_i32_ty], [IntrNoMem]>;
160 def int_frameaddress  : Intrinsic<[llvm_ptr_ty, llvm_i32_ty], [IntrNoMem]>;
161
162 // Note: we treat stacksave/stackrestore as writemem because we don't otherwise
163 // model their dependencies on allocas.
164 def int_stacksave     : Intrinsic<[llvm_ptr_ty]>,
165                         GCCBuiltin<"__builtin_stack_save">;
166 def int_stackrestore  : Intrinsic<[llvm_void_ty, llvm_ptr_ty]>,
167                         GCCBuiltin<"__builtin_stack_restore">;
168 // IntrWriteArgMem is more pessimistic than strictly necessary for prefetch,
169 // however it does conveniently prevent the prefetch from being reordered
170 // with respect to nearby accesses to the same memory.
171 def int_prefetch      : Intrinsic<[llvm_void_ty, llvm_ptr_ty, 
172                                    llvm_i32_ty, llvm_i32_ty],
173                                   [IntrWriteArgMem]>;
174 def int_pcmarker      : Intrinsic<[llvm_void_ty, llvm_i32_ty]>;
175
176 def int_readcyclecounter : Intrinsic<[llvm_i64_ty]>;
177
178 //===------------------- Standard C Library Intrinsics --------------------===//
179 //
180
181 let Properties = [IntrWriteArgMem] in {
182   def int_memcpy_i32  : Intrinsic<[llvm_void_ty, llvm_ptr_ty, llvm_ptr_ty,
183                                    llvm_i32_ty, llvm_i32_ty]>;
184   def int_memcpy_i64  : Intrinsic<[llvm_void_ty, llvm_ptr_ty, llvm_ptr_ty,
185                                    llvm_i64_ty, llvm_i32_ty]>;
186   def int_memmove_i32 : Intrinsic<[llvm_void_ty, llvm_ptr_ty, llvm_ptr_ty,
187                                    llvm_i32_ty, llvm_i32_ty]>;
188   def int_memmove_i64 : Intrinsic<[llvm_void_ty, llvm_ptr_ty, llvm_ptr_ty,
189                                    llvm_i64_ty, llvm_i32_ty]>;
190   def int_memset_i32  : Intrinsic<[llvm_void_ty, llvm_ptr_ty, llvm_i8_ty,
191                                    llvm_i32_ty, llvm_i32_ty]>;
192   def int_memset_i64  : Intrinsic<[llvm_void_ty, llvm_ptr_ty, llvm_i8_ty,
193                                    llvm_i64_ty, llvm_i32_ty]>;
194 }
195
196 // These functions do not actually read memory, but they are sensitive to the
197 // rounding mode.  This needs to be modelled separately; in the meantime
198 // declaring them as reading memory is conservatively correct.
199 let Properties = [IntrReadMem] in {
200   def int_sqrt : Intrinsic<[llvm_anyfloat_ty, LLVMMatchType<0>]>;
201   def int_powi : Intrinsic<[llvm_anyfloat_ty, LLVMMatchType<0>, llvm_i32_ty]>;
202   def int_sin  : Intrinsic<[llvm_anyfloat_ty, LLVMMatchType<0>]>;
203   def int_cos  : Intrinsic<[llvm_anyfloat_ty, LLVMMatchType<0>]>; 
204   def int_pow  : Intrinsic<[llvm_anyfloat_ty,
205                             LLVMMatchType<0>, LLVMMatchType<0>]>;
206   def int_log  : Intrinsic<[llvm_anyfloat_ty, LLVMMatchType<0>]>;
207   def int_log10: Intrinsic<[llvm_anyfloat_ty, LLVMMatchType<0>]>;
208   def int_log2 : Intrinsic<[llvm_anyfloat_ty, LLVMMatchType<0>]>;
209   def int_exp  : Intrinsic<[llvm_anyfloat_ty, LLVMMatchType<0>]>;
210   def int_exp2 : Intrinsic<[llvm_anyfloat_ty, LLVMMatchType<0>]>;
211 }
212
213 // NOTE: these are internal interfaces.
214 def int_setjmp     : Intrinsic<[llvm_i32_ty , llvm_ptr_ty]>;
215 def int_longjmp    : Intrinsic<[llvm_void_ty, llvm_ptr_ty, llvm_i32_ty]>;
216 def int_sigsetjmp  : Intrinsic<[llvm_i32_ty , llvm_ptr_ty, llvm_i32_ty]>;
217 def int_siglongjmp : Intrinsic<[llvm_void_ty, llvm_ptr_ty, llvm_i32_ty]>;
218
219 //===-------------------- Bit Manipulation Intrinsics ---------------------===//
220 //
221
222 // None of these intrinsics accesses memory at all.
223 let Properties = [IntrNoMem] in {
224   def int_bswap: Intrinsic<[llvm_anyint_ty, LLVMMatchType<0>]>;
225   def int_ctpop: Intrinsic<[llvm_anyint_ty, LLVMMatchType<0>]>;
226   def int_ctlz : Intrinsic<[llvm_anyint_ty, LLVMMatchType<0>]>;
227   def int_cttz : Intrinsic<[llvm_anyint_ty, LLVMMatchType<0>]>;
228   def int_part_select : 
229      Intrinsic<[llvm_anyint_ty, LLVMMatchType<0>, llvm_i32_ty, llvm_i32_ty]>;
230   def int_part_set :
231      Intrinsic<[llvm_anyint_ty, LLVMMatchType<0>, llvm_anyint_ty, llvm_i32_ty, 
232                 llvm_i32_ty]>;
233 }
234
235 //===------------------------ Debugger Intrinsics -------------------------===//
236 //
237
238 def int_dbg_stoppoint    : Intrinsic<[llvm_void_ty,
239                                       llvm_i32_ty, llvm_i32_ty, 
240                                       llvm_descriptor_ty]>;
241 def int_dbg_region_start : Intrinsic<[llvm_void_ty, llvm_descriptor_ty]>;
242 def int_dbg_region_end   : Intrinsic<[llvm_void_ty, llvm_descriptor_ty]>;
243 def int_dbg_func_start   : Intrinsic<[llvm_void_ty, llvm_descriptor_ty]>;
244 def int_dbg_declare      : Intrinsic<[llvm_void_ty, llvm_descriptor_ty,
245                                                     llvm_descriptor_ty]>;
246
247 //===------------------ Exception Handling Intrinsics----------------------===//
248 //
249 def int_eh_exception     : Intrinsic<[llvm_ptr_ty]>;
250 def int_eh_selector_i32  : Intrinsic<[llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty,
251                                                    llvm_vararg_ty]>;
252 def int_eh_selector_i64  : Intrinsic<[llvm_i64_ty, llvm_ptr_ty, llvm_ptr_ty,
253                                                    llvm_vararg_ty]>;
254
255 def int_eh_typeid_for_i32 : Intrinsic<[llvm_i32_ty, llvm_ptr_ty]>;
256 def int_eh_typeid_for_i64 : Intrinsic<[llvm_i64_ty, llvm_ptr_ty]>;
257
258 def int_eh_return     : Intrinsic<[llvm_void_ty, llvm_i32_ty, llvm_ptr_ty]>,
259                         GCCBuiltin<"__builtin_eh_return">;
260
261 def int_eh_unwind_init: Intrinsic<[llvm_void_ty]>,
262                         GCCBuiltin<"__builtin_unwind_init">;
263
264 def int_eh_dwarf_cfa  : Intrinsic<[llvm_ptr_ty, llvm_i32_ty]>;
265
266 //===---------------- Generic Variable Attribute Intrinsics----------------===//
267 //
268 def int_var_annotation : Intrinsic<[llvm_void_ty, llvm_ptr_ty, llvm_ptr_ty,
269                                     llvm_ptr_ty, llvm_i32_ty], 
270                                     [], "llvm.var.annotation">;
271                                     
272 def int_annotation : Intrinsic<[llvm_anyint_ty, LLVMMatchType<0>, llvm_ptr_ty,
273                                 llvm_ptr_ty, llvm_i32_ty], 
274                                 [], "llvm.annotation">;
275
276 //===------------------------ Trampoline Intrinsics -----------------------===//
277 //
278 def int_init_trampoline : Intrinsic<[llvm_ptr_ty, llvm_ptr_ty, llvm_ptr_ty,
279                                      llvm_ptr_ty], []>,
280                           GCCBuiltin<"__builtin_init_trampoline">;
281
282 //===------------------------- Atomic Intrinsics --------------------------===//
283 //
284 def int_memory_barrier : Intrinsic<[llvm_void_ty, llvm_i1_ty, llvm_i1_ty, 
285                                     llvm_i1_ty, llvm_i1_ty, llvm_i1_ty], []>;
286
287 def int_atomic_cmp_swap : Intrinsic<[llvm_anyint_ty,
288                                   LLVMAnyPointerType<LLVMMatchType<0>>,
289                                   LLVMMatchType<0>, LLVMMatchType<0>],
290                                  [IntrWriteArgMem]>,
291                            GCCBuiltin<"__sync_val_compare_and_swap">;
292 def int_atomic_load_add : Intrinsic<[llvm_anyint_ty,
293                                   LLVMAnyPointerType<LLVMMatchType<0>>,
294                                   LLVMMatchType<0>],
295                                  [IntrWriteArgMem]>,
296                            GCCBuiltin<"__sync_fetch_and_add">;
297 def int_atomic_swap     : Intrinsic<[llvm_anyint_ty,
298                                   LLVMAnyPointerType<LLVMMatchType<0>>,
299                                   LLVMMatchType<0>],
300                                 [IntrWriteArgMem]>,
301                            GCCBuiltin<"__sync_lock_test_and_set">;
302 def int_atomic_load_sub : Intrinsic<[llvm_anyint_ty,
303                                   LLVMAnyPointerType<LLVMMatchType<0>>,
304                                   LLVMMatchType<0>],
305                                  [IntrWriteArgMem]>,
306                            GCCBuiltin<"__sync_fetch_and_sub">;
307 def int_atomic_load_and : Intrinsic<[llvm_anyint_ty,
308                                   LLVMAnyPointerType<LLVMMatchType<0>>,
309                                   LLVMMatchType<0>],
310                                  [IntrWriteArgMem]>,
311                            GCCBuiltin<"__sync_fetch_and_and">;
312 def int_atomic_load_or   : Intrinsic<[llvm_anyint_ty,
313                                   LLVMAnyPointerType<LLVMMatchType<0>>,
314                                   LLVMMatchType<0>],
315                                  [IntrWriteArgMem]>,
316                            GCCBuiltin<"__sync_fetch_and_or">;
317 def int_atomic_load_xor : Intrinsic<[llvm_anyint_ty,
318                                   LLVMAnyPointerType<LLVMMatchType<0>>,
319                                   LLVMMatchType<0>],
320                                  [IntrWriteArgMem]>,
321                            GCCBuiltin<"__sync_fetch_and_xor">;
322 def int_atomic_load_nand : Intrinsic<[llvm_anyint_ty,
323                                   LLVMAnyPointerType<LLVMMatchType<0>>,
324                                   LLVMMatchType<0>],
325                                  [IntrWriteArgMem]>,
326                            GCCBuiltin<"__sync_fetch_and_nand">;
327 def int_atomic_load_min  : Intrinsic<[llvm_anyint_ty,
328                                    LLVMAnyPointerType<LLVMMatchType<0>>,
329                                    LLVMMatchType<0>],
330                                   [IntrWriteArgMem]>,
331                            GCCBuiltin<"__sync_fetch_and_min">;
332 def int_atomic_load_max  : Intrinsic<[llvm_anyint_ty,
333                                    LLVMAnyPointerType<LLVMMatchType<0>>,
334                                    LLVMMatchType<0>],
335                                   [IntrWriteArgMem]>,
336                            GCCBuiltin<"__sync_fetch_and_max">;
337 def int_atomic_load_umin : Intrinsic<[llvm_anyint_ty,
338                                    LLVMAnyPointerType<LLVMMatchType<0>>,
339                                    LLVMMatchType<0>],
340                                   [IntrWriteArgMem]>,
341                            GCCBuiltin<"__sync_fetch_and_umin">;
342 def int_atomic_load_umax : Intrinsic<[llvm_anyint_ty,
343                                    LLVMAnyPointerType<LLVMMatchType<0>>,
344                                    LLVMMatchType<0>],
345                                   [IntrWriteArgMem]>,
346                            GCCBuiltin<"__sync_fetch_and_umax">;
347                                   
348 //===-------------------------- Other Intrinsics --------------------------===//
349 //
350 def int_flt_rounds : Intrinsic<[llvm_i32_ty]>,
351                      GCCBuiltin<"__builtin_flt_rounds">;
352 def int_trap : Intrinsic<[llvm_void_ty]>,
353                GCCBuiltin<"__builtin_trap">;
354
355 //===----------------------------------------------------------------------===//
356 // Target-specific intrinsics
357 //===----------------------------------------------------------------------===//
358
359 include "llvm/IntrinsicsPowerPC.td"
360 include "llvm/IntrinsicsX86.td"
361 include "llvm/IntrinsicsARM.td"
362 include "llvm/IntrinsicsCellSPU.td"