LLVM: Add alias type defenitions to LlvmModule.
[ghc.git] / compiler / llvmGen / Llvm / Types.hs
1 --------------------------------------------------------------------------------
2 -- | The LLVM Type System.
3 --
4
5 module Llvm.Types where
6
7 #include "HsVersions.h"
8 #include "ghcconfig.h"
9
10 import Data.Char
11 import Numeric
12
13 import Constants
14 import FastString
15 import Unique
16
17 -- from NCG
18 import PprBase
19
20 -- -----------------------------------------------------------------------------
21 -- * LLVM Basic Types and Variables
22 --
23
24 -- | A global mutable variable. Maybe defined or external
25 type LMGlobal = (LlvmVar, Maybe LlvmStatic)
26 -- | A String in LLVM
27 type LMString = FastString
28
29 -- | A type alias
30 type LlvmAlias = (LMString, LlvmType)
31
32 -- | Llvm Types
33 data LlvmType
34 = LMInt Int -- ^ An integer with a given width in bits.
35 | LMFloat -- ^ 32 bit floating point
36 | LMDouble -- ^ 64 bit floating point
37 | LMFloat80 -- ^ 80 bit (x86 only) floating point
38 | LMFloat128 -- ^ 128 bit floating point
39 | LMPointer LlvmType -- ^ A pointer to a 'LlvmType'
40 | LMArray Int LlvmType -- ^ An array of 'LlvmType'
41 | LMLabel -- ^ A 'LlvmVar' can represent a label (address)
42 | LMVoid -- ^ Void type
43 | LMStruct [LlvmType] -- ^ Structure type
44 | LMAlias LlvmAlias -- ^ A type alias
45
46 -- | Function type, used to create pointers to functions
47 | LMFunction LlvmFunctionDecl
48 deriving (Eq)
49
50 instance Show LlvmType where
51 show (LMInt size ) = "i" ++ show size
52 show (LMFloat ) = "float"
53 show (LMDouble ) = "double"
54 show (LMFloat80 ) = "x86_fp80"
55 show (LMFloat128 ) = "fp128"
56 show (LMPointer x ) = show x ++ "*"
57 show (LMArray nr tp ) = "[" ++ show nr ++ " x " ++ show tp ++ "]"
58 show (LMLabel ) = "label"
59 show (LMVoid ) = "void"
60 show (LMStruct tys ) = "<{" ++ (commaCat tys) ++ "}>"
61
62 show (LMFunction (LlvmFunctionDecl _ _ _ r varg p _))
63 = let args = ((drop 1).concat) $ -- use drop since it can handle empty lists
64 map (\(t,a) -> "," ++ show t ++ " " ++ spaceCat a) p
65 varg' = case varg of
66 VarArgs | not (null args) -> ", ..."
67 | otherwise -> "..."
68 _otherwise -> ""
69 in show r ++ " (" ++ args ++ varg' ++ ")"
70
71 show (LMAlias (s,_)) = "%" ++ unpackFS s
72
73 -- | An LLVM section defenition. If Nothing then let LLVM decide the section
74 type LMSection = Maybe LMString
75 type LMAlign = Maybe Int
76 type LMConst = Bool -- ^ is a variable constant or not
77
78 -- | Llvm Variables
79 data LlvmVar
80 -- | Variables with a global scope.
81 = LMGlobalVar LMString LlvmType LlvmLinkageType LMSection LMAlign LMConst
82 -- | Variables local to a function or parameters.
83 | LMLocalVar Unique LlvmType
84 -- | Named local variables. Sometimes we need to be able to explicitly name
85 -- variables (e.g for function arguments).
86 | LMNLocalVar LMString LlvmType
87 -- | A constant variable
88 | LMLitVar LlvmLit
89 deriving (Eq)
90
91 instance Show LlvmVar where
92 show (LMLitVar x) = show x
93 show (x ) = show (getVarType x) ++ " " ++ getName x
94
95
96 -- | Llvm Literal Data.
97 --
98 -- These can be used inline in expressions.
99 data LlvmLit
100 -- | Refers to an integer constant (i64 42).
101 = LMIntLit Integer LlvmType
102 -- | Floating point literal
103 | LMFloatLit Double LlvmType
104 -- | Literal NULL, only applicable to pointer types
105 | LMNullLit LlvmType
106 -- | Undefined value, random bit pattern. Useful for optimisations.
107 | LMUndefLit LlvmType
108 deriving (Eq)
109
110 instance Show LlvmLit where
111 show l = show (getLitType l) ++ " " ++ getLit l
112
113
114 -- | Llvm Static Data.
115 --
116 -- These represent the possible global level variables and constants.
117 data LlvmStatic
118 = LMComment LMString -- ^ A comment in a static section
119 | LMStaticLit LlvmLit -- ^ A static variant of a literal value
120 | LMUninitType LlvmType -- ^ For uninitialised data
121 | LMStaticStr LMString LlvmType -- ^ Defines a static 'LMString'
122 | LMStaticArray [LlvmStatic] LlvmType -- ^ A static array
123 | LMStaticStruc [LlvmStatic] LlvmType -- ^ A static structure type
124 | LMStaticPointer LlvmVar -- ^ A pointer to other data
125
126 -- static expressions, could split out but leave
127 -- for moment for ease of use. Not many of them.
128
129 | LMBitc LlvmStatic LlvmType -- ^ Pointer to Pointer conversion
130 | LMPtoI LlvmStatic LlvmType -- ^ Pointer to Integer conversion
131 | LMAdd LlvmStatic LlvmStatic -- ^ Constant addition operation
132 | LMSub LlvmStatic LlvmStatic -- ^ Constant subtraction operation
133
134 instance Show LlvmStatic where
135 show (LMComment s) = "; " ++ unpackFS s
136 show (LMStaticLit l ) = show l
137 show (LMUninitType t) = show t ++ " undef"
138 show (LMStaticStr s t) = show t ++ " c\"" ++ unpackFS s ++ "\\00\""
139
140 show (LMStaticArray d t)
141 = let struc = case d of
142 [] -> "[]"
143 ts -> "[" ++ show (head ts) ++
144 concat (map (\x -> "," ++ show x) (tail ts)) ++ "]"
145 in show t ++ " " ++ struc
146
147 show (LMStaticStruc d t)
148 = let struc = case d of
149 [] -> "<{}>"
150 ts -> "<{" ++ show (head ts) ++
151 concat (map (\x -> "," ++ show x) (tail ts)) ++ "}>"
152 in show t ++ " " ++ struc
153
154 show (LMStaticPointer v) = show v
155
156 show (LMBitc v t)
157 = show t ++ " bitcast (" ++ show v ++ " to " ++ show t ++ ")"
158
159 show (LMPtoI v t)
160 = show t ++ " ptrtoint (" ++ show v ++ " to " ++ show t ++ ")"
161
162 show (LMAdd s1 s2)
163 = let ty1 = getStatType s1
164 op = if isFloat ty1 then " fadd (" else " add ("
165 in if ty1 == getStatType s2
166 then show ty1 ++ op ++ show s1 ++ "," ++ show s2 ++ ")"
167 else error $ "LMAdd with different types! s1: "
168 ++ show s1 ++ ", s2: " ++ show s2
169 show (LMSub s1 s2)
170 = let ty1 = getStatType s1
171 op = if isFloat ty1 then " fsub (" else " sub ("
172 in if ty1 == getStatType s2
173 then show ty1 ++ op ++ show s1 ++ "," ++ show s2 ++ ")"
174 else error $ "LMSub with different types! s1: "
175 ++ show s1 ++ ", s2: " ++ show s2
176
177
178 -- | Concatenate an array together, separated by commas
179 commaCat :: Show a => [a] -> String
180 commaCat [] = ""
181 commaCat x = show (head x) ++ (concat $ map (\y -> "," ++ show y) (tail x))
182
183 -- | Concatenate an array together, separated by commas
184 spaceCat :: Show a => [a] -> String
185 spaceCat [] = ""
186 spaceCat x = show (head x) ++ (concat $ map (\y -> " " ++ show y) (tail x))
187
188 -- -----------------------------------------------------------------------------
189 -- ** Operations on LLVM Basic Types and Variables
190 --
191
192 -- | Return the variable name or value of the 'LlvmVar'
193 -- in Llvm IR textual representation (e.g. @\@x@, @%y@ or @42@).
194 getName :: LlvmVar -> String
195 getName v@(LMGlobalVar _ _ _ _ _ _) = "@" ++ getPlainName v
196 getName v@(LMLocalVar _ _ ) = "%" ++ getPlainName v
197 getName v@(LMNLocalVar _ _ ) = "%" ++ getPlainName v
198 getName v@(LMLitVar _ ) = getPlainName v
199
200 -- | Return the variable name or value of the 'LlvmVar'
201 -- in a plain textual representation (e.g. @x@, @y@ or @42@).
202 getPlainName :: LlvmVar -> String
203 getPlainName (LMGlobalVar x _ _ _ _ _) = unpackFS x
204 getPlainName (LMLocalVar x _ ) = show x
205 getPlainName (LMNLocalVar x _ ) = unpackFS x
206 getPlainName (LMLitVar x ) = getLit x
207
208 -- | Print a literal value. No type.
209 getLit :: LlvmLit -> String
210 getLit (LMIntLit i _) = show ((fromInteger i)::Int)
211 getLit (LMFloatLit r LMFloat ) = fToStr $ realToFrac r
212 getLit (LMFloatLit r LMDouble) = dToStr r
213 getLit f@(LMFloatLit _ _) = error $ "Can't print this float literal!" ++ show f
214 getLit (LMNullLit _) = "null"
215 getLit (LMUndefLit _) = "undef"
216
217 -- | Return the 'LlvmType' of the 'LlvmVar'
218 getVarType :: LlvmVar -> LlvmType
219 getVarType (LMGlobalVar _ y _ _ _ _) = y
220 getVarType (LMLocalVar _ y ) = y
221 getVarType (LMNLocalVar _ y ) = y
222 getVarType (LMLitVar l ) = getLitType l
223
224 -- | Return the 'LlvmType' of a 'LlvmLit'
225 getLitType :: LlvmLit -> LlvmType
226 getLitType (LMIntLit _ t) = t
227 getLitType (LMFloatLit _ t) = t
228 getLitType (LMNullLit t) = t
229 getLitType (LMUndefLit t) = t
230
231 -- | Return the 'LlvmType' of the 'LlvmStatic'
232 getStatType :: LlvmStatic -> LlvmType
233 getStatType (LMStaticLit l ) = getLitType l
234 getStatType (LMUninitType t) = t
235 getStatType (LMStaticStr _ t) = t
236 getStatType (LMStaticArray _ t) = t
237 getStatType (LMStaticStruc _ t) = t
238 getStatType (LMStaticPointer v) = getVarType v
239 getStatType (LMBitc _ t) = t
240 getStatType (LMPtoI _ t) = t
241 getStatType (LMAdd t _) = getStatType t
242 getStatType (LMSub t _) = getStatType t
243 getStatType (LMComment _) = error "Can't call getStatType on LMComment!"
244
245 -- | Return the 'LlvmType' of the 'LMGlobal'
246 getGlobalType :: LMGlobal -> LlvmType
247 getGlobalType (v, _) = getVarType v
248
249 -- | Return the 'LlvmVar' part of a 'LMGlobal'
250 getGlobalVar :: LMGlobal -> LlvmVar
251 getGlobalVar (v, _) = v
252
253 -- | Return the 'LlvmLinkageType' for a 'LlvmVar'
254 getLink :: LlvmVar -> LlvmLinkageType
255 getLink (LMGlobalVar _ _ l _ _ _) = l
256 getLink _ = Internal
257
258 -- | Add a pointer indirection to the supplied type. 'LMLabel' and 'LMVoid'
259 -- cannot be lifted.
260 pLift :: LlvmType -> LlvmType
261 pLift (LMLabel) = error "Labels are unliftable"
262 pLift (LMVoid) = error "Voids are unliftable"
263 pLift x = LMPointer x
264
265 -- | Lower a variable of 'LMPointer' type.
266 pVarLift :: LlvmVar -> LlvmVar
267 pVarLift (LMGlobalVar s t l x a c) = LMGlobalVar s (pLift t) l x a c
268 pVarLift (LMLocalVar s t ) = LMLocalVar s (pLift t)
269 pVarLift (LMNLocalVar s t ) = LMNLocalVar s (pLift t)
270 pVarLift (LMLitVar _ ) = error $ "Can't lower a literal type!"
271
272 -- | Remove the pointer indirection of the supplied type. Only 'LMPointer'
273 -- constructors can be lowered.
274 pLower :: LlvmType -> LlvmType
275 pLower (LMPointer x) = x
276 pLower x = error $ show x ++ " is a unlowerable type, need a pointer"
277
278 -- | Lower a variable of 'LMPointer' type.
279 pVarLower :: LlvmVar -> LlvmVar
280 pVarLower (LMGlobalVar s t l x a c) = LMGlobalVar s (pLower t) l x a c
281 pVarLower (LMLocalVar s t ) = LMLocalVar s (pLower t)
282 pVarLower (LMNLocalVar s t ) = LMNLocalVar s (pLower t)
283 pVarLower (LMLitVar _ ) = error $ "Can't lower a literal type!"
284
285 -- | Test if the given 'LlvmType' is an integer
286 isInt :: LlvmType -> Bool
287 isInt (LMInt _) = True
288 isInt _ = False
289
290 -- | Test if the given 'LlvmType' is a floating point type
291 isFloat :: LlvmType -> Bool
292 isFloat LMFloat = True
293 isFloat LMDouble = True
294 isFloat LMFloat80 = True
295 isFloat LMFloat128 = True
296 isFloat _ = False
297
298 -- | Test if the given 'LlvmType' is an 'LMPointer' construct
299 isPointer :: LlvmType -> Bool
300 isPointer (LMPointer _) = True
301 isPointer _ = False
302
303 -- | Test if a 'LlvmVar' is global.
304 isGlobal :: LlvmVar -> Bool
305 isGlobal (LMGlobalVar _ _ _ _ _ _) = True
306 isGlobal _ = False
307
308 -- | Width in bits of an 'LlvmType', returns 0 if not applicable
309 llvmWidthInBits :: LlvmType -> Int
310 llvmWidthInBits (LMInt n) = n
311 llvmWidthInBits (LMFloat) = 32
312 llvmWidthInBits (LMDouble) = 64
313 llvmWidthInBits (LMFloat80) = 80
314 llvmWidthInBits (LMFloat128) = 128
315 -- Could return either a pointer width here or the width of what
316 -- it points to. We will go with the former for now.
317 llvmWidthInBits (LMPointer _) = llvmWidthInBits llvmWord
318 llvmWidthInBits (LMArray _ _) = llvmWidthInBits llvmWord
319 llvmWidthInBits LMLabel = 0
320 llvmWidthInBits LMVoid = 0
321 llvmWidthInBits (LMStruct tys) = sum $ map llvmWidthInBits tys
322 llvmWidthInBits (LMFunction _) = 0
323 llvmWidthInBits (LMAlias (_,t)) = llvmWidthInBits t
324
325
326 -- -----------------------------------------------------------------------------
327 -- ** Shortcut for Common Types
328 --
329
330 i128, i64, i32, i16, i8, i1, i8Ptr :: LlvmType
331 i128 = LMInt 128
332 i64 = LMInt 64
333 i32 = LMInt 32
334 i16 = LMInt 16
335 i8 = LMInt 8
336 i1 = LMInt 1
337 i8Ptr = pLift i8
338
339 -- | The target architectures word size
340 llvmWord, llvmWordPtr :: LlvmType
341 llvmWord = LMInt (wORD_SIZE * 8)
342 llvmWordPtr = pLift llvmWord
343
344 -- -----------------------------------------------------------------------------
345 -- * LLVM Function Types
346 --
347
348 -- | An LLVM Function
349 data LlvmFunctionDecl = LlvmFunctionDecl {
350 -- | Unique identifier of the function
351 decName :: LMString,
352 -- | LinkageType of the function
353 funcLinkage :: LlvmLinkageType,
354 -- | The calling convention of the function
355 funcCc :: LlvmCallConvention,
356 -- | Type of the returned value
357 decReturnType :: LlvmType,
358 -- | Indicates if this function uses varargs
359 decVarargs :: LlvmParameterListType,
360 -- | Parameter types and attributes
361 decParams :: [LlvmParameter],
362 -- | Function align value, must be power of 2
363 funcAlign :: LMAlign
364 }
365 deriving (Eq)
366
367 instance Show LlvmFunctionDecl where
368 show (LlvmFunctionDecl n l c r varg p a)
369 = let args = ((drop 1).concat) $ -- use drop since it can handle empty lists
370 map (\(t,a) -> "," ++ show t ++ " " ++ spaceCat a) p
371 varg' = case varg of
372 VarArgs | not (null args) -> ", ..."
373 | otherwise -> "..."
374 _otherwise -> ""
375 align = case a of
376 Just a' -> " align " ++ show a'
377 Nothing -> ""
378 in show l ++ " " ++ show c ++ " " ++ show r ++ " @" ++ unpackFS n ++
379 "(" ++ args ++ varg' ++ ")" ++ align
380
381 type LlvmFunctionDecls = [LlvmFunctionDecl]
382
383 type LlvmParameter = (LlvmType, [LlvmParamAttr])
384
385 -- | LLVM Parameter Attributes.
386 --
387 -- Parameter attributes are used to communicate additional information about
388 -- the result or parameters of a function
389 data LlvmParamAttr
390 -- | This indicates to the code generator that the parameter or return value
391 -- should be zero-extended to a 32-bit value by the caller (for a parameter)
392 -- or the callee (for a return value).
393 = ZeroExt
394 -- | This indicates to the code generator that the parameter or return value
395 -- should be sign-extended to a 32-bit value by the caller (for a parameter)
396 -- or the callee (for a return value).
397 | SignExt
398 -- | This indicates that this parameter or return value should be treated in
399 -- a special target-dependent fashion during while emitting code for a
400 -- function call or return (usually, by putting it in a register as opposed
401 -- to memory).
402 | InReg
403 -- | This indicates that the pointer parameter should really be passed by
404 -- value to the function.
405 | ByVal
406 -- | This indicates that the pointer parameter specifies the address of a
407 -- structure that is the return value of the function in the source program.
408 | SRet
409 -- | This indicates that the pointer does not alias any global or any other
410 -- parameter.
411 | NoAlias
412 -- | This indicates that the callee does not make any copies of the pointer
413 -- that outlive the callee itself
414 | NoCapture
415 -- | This indicates that the pointer parameter can be excised using the
416 -- trampoline intrinsics.
417 | Nest
418 deriving (Eq)
419
420 instance Show LlvmParamAttr where
421 show ZeroExt = "zeroext"
422 show SignExt = "signext"
423 show InReg = "inreg"
424 show ByVal = "byval"
425 show SRet = "sret"
426 show NoAlias = "noalias"
427 show NoCapture = "nocapture"
428 show Nest = "nest"
429
430 -- | Llvm Function Attributes.
431 --
432 -- Function attributes are set to communicate additional information about a
433 -- function. Function attributes are considered to be part of the function,
434 -- not of the function type, so functions with different parameter attributes
435 -- can have the same function type. Functions can have multiple attributes.
436 --
437 -- Descriptions taken from <http://llvm.org/docs/LangRef.html#fnattrs>
438 data LlvmFuncAttr
439 -- | This attribute indicates that the inliner should attempt to inline this
440 -- function into callers whenever possible, ignoring any active inlining
441 -- size threshold for this caller.
442 = AlwaysInline
443 -- | This attribute indicates that the source code contained a hint that
444 -- inlining this function is desirable (such as the \"inline\" keyword in
445 -- C/C++). It is just a hint; it imposes no requirements on the inliner.
446 | InlineHint
447 -- | This attribute indicates that the inliner should never inline this
448 -- function in any situation. This attribute may not be used together
449 -- with the alwaysinline attribute.
450 | NoInline
451 -- | This attribute suggests that optimization passes and code generator
452 -- passes make choices that keep the code size of this function low, and
453 -- otherwise do optimizations specifically to reduce code size.
454 | OptSize
455 -- | This function attribute indicates that the function never returns
456 -- normally. This produces undefined behavior at runtime if the function
457 -- ever does dynamically return.
458 | NoReturn
459 -- | This function attribute indicates that the function never returns with
460 -- an unwind or exceptional control flow. If the function does unwind, its
461 -- runtime behavior is undefined.
462 | NoUnwind
463 -- | This attribute indicates that the function computes its result (or
464 -- decides to unwind an exception) based strictly on its arguments, without
465 -- dereferencing any pointer arguments or otherwise accessing any mutable
466 -- state (e.g. memory, control registers, etc) visible to caller functions.
467 -- It does not write through any pointer arguments (including byval
468 -- arguments) and never changes any state visible to callers. This means
469 -- that it cannot unwind exceptions by calling the C++ exception throwing
470 -- methods, but could use the unwind instruction.
471 | ReadNone
472 -- | This attribute indicates that the function does not write through any
473 -- pointer arguments (including byval arguments) or otherwise modify any
474 -- state (e.g. memory, control registers, etc) visible to caller functions.
475 -- It may dereference pointer arguments and read state that may be set in
476 -- the caller. A readonly function always returns the same value (or unwinds
477 -- an exception identically) when called with the same set of arguments and
478 -- global state. It cannot unwind an exception by calling the C++ exception
479 -- throwing methods, but may use the unwind instruction.
480 | ReadOnly
481 -- | This attribute indicates that the function should emit a stack smashing
482 -- protector. It is in the form of a \"canary\"—a random value placed on the
483 -- stack before the local variables that's checked upon return from the
484 -- function to see if it has been overwritten. A heuristic is used to
485 -- determine if a function needs stack protectors or not.
486 --
487 -- If a function that has an ssp attribute is inlined into a function that
488 -- doesn't have an ssp attribute, then the resulting function will have an
489 -- ssp attribute.
490 | Ssp
491 -- | This attribute indicates that the function should always emit a stack
492 -- smashing protector. This overrides the ssp function attribute.
493 --
494 -- If a function that has an sspreq attribute is inlined into a function
495 -- that doesn't have an sspreq attribute or which has an ssp attribute,
496 -- then the resulting function will have an sspreq attribute.
497 | SspReq
498 -- | This attribute indicates that the code generator should not use a red
499 -- zone, even if the target-specific ABI normally permits it.
500 | NoRedZone
501 -- | This attributes disables implicit floating point instructions.
502 | NoImplicitFloat
503 -- | This attribute disables prologue / epilogue emission for the function.
504 -- This can have very system-specific consequences.
505 | Naked
506 deriving (Eq)
507
508 instance Show LlvmFuncAttr where
509 show AlwaysInline = "alwaysinline"
510 show InlineHint = "inlinehint"
511 show NoInline = "noinline"
512 show OptSize = "optsize"
513 show NoReturn = "noreturn"
514 show NoUnwind = "nounwind"
515 show ReadNone = "readnon"
516 show ReadOnly = "readonly"
517 show Ssp = "ssp"
518 show SspReq = "ssqreq"
519 show NoRedZone = "noredzone"
520 show NoImplicitFloat = "noimplicitfloat"
521 show Naked = "naked"
522
523
524 -- | Different types to call a function.
525 data LlvmCallType
526 -- | Normal call, allocate a new stack frame.
527 = StdCall
528 -- | Tail call, perform the call in the current stack frame.
529 | TailCall
530 deriving (Eq,Show)
531
532 -- | Different calling conventions a function can use.
533 data LlvmCallConvention
534 -- | The C calling convention.
535 -- This calling convention (the default if no other calling convention is
536 -- specified) matches the target C calling conventions. This calling
537 -- convention supports varargs function calls and tolerates some mismatch in
538 -- the declared prototype and implemented declaration of the function (as
539 -- does normal C).
540 = CC_Ccc
541 -- | This calling convention attempts to make calls as fast as possible
542 -- (e.g. by passing things in registers). This calling convention allows
543 -- the target to use whatever tricks it wants to produce fast code for the
544 -- target, without having to conform to an externally specified ABI
545 -- (Application Binary Interface). Implementations of this convention should
546 -- allow arbitrary tail call optimization to be supported. This calling
547 -- convention does not support varargs and requires the prototype of al
548 -- callees to exactly match the prototype of the function definition.
549 | CC_Fastcc
550 -- | This calling convention attempts to make code in the caller as efficient
551 -- as possible under the assumption that the call is not commonly executed.
552 -- As such, these calls often preserve all registers so that the call does
553 -- not break any live ranges in the caller side. This calling convention
554 -- does not support varargs and requires the prototype of all callees to
555 -- exactly match the prototype of the function definition.
556 | CC_Coldcc
557 -- | Any calling convention may be specified by number, allowing
558 -- target-specific calling conventions to be used. Target specific calling
559 -- conventions start at 64.
560 | CC_Ncc Int
561 -- | X86 Specific 'StdCall' convention. LLVM includes a specific alias for it
562 -- rather than just using CC_Ncc.
563 | CC_X86_Stdcc
564 deriving (Eq)
565
566 instance Show LlvmCallConvention where
567 show CC_Ccc = "ccc"
568 show CC_Fastcc = "fastcc"
569 show CC_Coldcc = "coldcc"
570 show (CC_Ncc i) = "cc " ++ show i
571 show CC_X86_Stdcc = "x86_stdcallcc"
572
573
574 -- | Functions can have a fixed amount of parameters, or a variable amount.
575 data LlvmParameterListType
576 -- Fixed amount of arguments.
577 = FixedArgs
578 -- Variable amount of arguments.
579 | VarArgs
580 deriving (Eq,Show)
581
582
583 -- | Linkage type of a symbol.
584 --
585 -- The description of the constructors is copied from the Llvm Assembly Language
586 -- Reference Manual <http://www.llvm.org/docs/LangRef.html#linkage>, because
587 -- they correspond to the Llvm linkage types.
588 data LlvmLinkageType
589 -- | Global values with internal linkage are only directly accessible by
590 -- objects in the current module. In particular, linking code into a module
591 -- with an internal global value may cause the internal to be renamed as
592 -- necessary to avoid collisions. Because the symbol is internal to the
593 -- module, all references can be updated. This corresponds to the notion
594 -- of the @static@ keyword in C.
595 = Internal
596 -- | Globals with @linkonce@ linkage are merged with other globals of the
597 -- same name when linkage occurs. This is typically used to implement
598 -- inline functions, templates, or other code which must be generated
599 -- in each translation unit that uses it. Unreferenced linkonce globals are
600 -- allowed to be discarded.
601 | LinkOnce
602 -- | @weak@ linkage is exactly the same as linkonce linkage, except that
603 -- unreferenced weak globals may not be discarded. This is used for globals
604 -- that may be emitted in multiple translation units, but that are not
605 -- guaranteed to be emitted into every translation unit that uses them. One
606 -- example of this are common globals in C, such as @int X;@ at global
607 -- scope.
608 | Weak
609 -- | @appending@ linkage may only be applied to global variables of pointer
610 -- to array type. When two global variables with appending linkage are
611 -- linked together, the two global arrays are appended together. This is
612 -- the Llvm, typesafe, equivalent of having the system linker append
613 -- together @sections@ with identical names when .o files are linked.
614 | Appending
615 -- | The semantics of this linkage follow the ELF model: the symbol is weak
616 -- until linked, if not linked, the symbol becomes null instead of being an
617 -- undefined reference.
618 | ExternWeak
619 -- | The symbol participates in linkage and can be used to resolve external
620 -- symbol references.
621 | ExternallyVisible
622 -- | Alias for 'ExternallyVisible' but with explicit textual form in LLVM
623 -- assembly.
624 | External
625 deriving (Eq)
626
627 instance Show LlvmLinkageType where
628 show Internal = "internal"
629 show LinkOnce = "linkonce"
630 show Weak = "weak"
631 show Appending = "appending"
632 show ExternWeak = "extern_weak"
633 -- ExternallyVisible does not have a textual representation, it is
634 -- the linkage type a function resolves to if no other is specified
635 -- in Llvm.
636 show ExternallyVisible = ""
637 show External = "external"
638
639
640 -- -----------------------------------------------------------------------------
641 -- * LLVM Operations
642 --
643
644 -- | Llvm binary operators machine operations.
645 data LlvmMachOp
646 = LM_MO_Add -- ^ add two integer, floating point or vector values.
647 | LM_MO_Sub -- ^ subtract two ...
648 | LM_MO_Mul -- ^ multiply ..
649 | LM_MO_UDiv -- ^ unsigned integer or vector division.
650 | LM_MO_SDiv -- ^ signed integer ..
651 | LM_MO_URem -- ^ unsigned integer or vector remainder (mod)
652 | LM_MO_SRem -- ^ signed ...
653
654 | LM_MO_FAdd -- ^ add two floating point or vector values.
655 | LM_MO_FSub -- ^ subtract two ...
656 | LM_MO_FMul -- ^ multiply ...
657 | LM_MO_FDiv -- ^ divide ...
658 | LM_MO_FRem -- ^ remainder ...
659
660 -- | Left shift
661 | LM_MO_Shl
662 -- | Logical shift right
663 -- Shift right, filling with zero
664 | LM_MO_LShr
665 -- | Arithmetic shift right
666 -- The most significant bits of the result will be equal to the sign bit of
667 -- the left operand.
668 | LM_MO_AShr
669
670 | LM_MO_And -- ^ AND bitwise logical operation.
671 | LM_MO_Or -- ^ OR bitwise logical operation.
672 | LM_MO_Xor -- ^ XOR bitwise logical operation.
673 deriving (Eq)
674
675 instance Show LlvmMachOp where
676 show LM_MO_Add = "add"
677 show LM_MO_Sub = "sub"
678 show LM_MO_Mul = "mul"
679 show LM_MO_UDiv = "udiv"
680 show LM_MO_SDiv = "sdiv"
681 show LM_MO_URem = "urem"
682 show LM_MO_SRem = "srem"
683 show LM_MO_FAdd = "fadd"
684 show LM_MO_FSub = "fsub"
685 show LM_MO_FMul = "fmul"
686 show LM_MO_FDiv = "fdiv"
687 show LM_MO_FRem = "frem"
688 show LM_MO_Shl = "shl"
689 show LM_MO_LShr = "lshr"
690 show LM_MO_AShr = "ashr"
691 show LM_MO_And = "and"
692 show LM_MO_Or = "or"
693 show LM_MO_Xor = "xor"
694
695
696 -- | Llvm compare operations.
697 data LlvmCmpOp
698 = LM_CMP_Eq -- ^ Equal (Signed and Unsigned)
699 | LM_CMP_Ne -- ^ Not equal (Signed and Unsigned)
700 | LM_CMP_Ugt -- ^ Unsigned greater than
701 | LM_CMP_Uge -- ^ Unsigned greater than or equal
702 | LM_CMP_Ult -- ^ Unsigned less than
703 | LM_CMP_Ule -- ^ Unsigned less than or equal
704 | LM_CMP_Sgt -- ^ Signed greater than
705 | LM_CMP_Sge -- ^ Signed greater than or equal
706 | LM_CMP_Slt -- ^ Signed less than
707 | LM_CMP_Sle -- ^ Signed less than or equal
708
709 -- Float comparisons. GHC uses a mix of ordered and unordered float
710 -- comparisons.
711 | LM_CMP_Feq -- ^ Float equal
712 | LM_CMP_Fne -- ^ Float not equal
713 | LM_CMP_Fgt -- ^ Float greater than
714 | LM_CMP_Fge -- ^ Float greater than or equal
715 | LM_CMP_Flt -- ^ Float less than
716 | LM_CMP_Fle -- ^ Float less than or equal
717 deriving (Eq)
718
719 instance Show LlvmCmpOp where
720 show LM_CMP_Eq = "eq"
721 show LM_CMP_Ne = "ne"
722 show LM_CMP_Ugt = "ugt"
723 show LM_CMP_Uge = "uge"
724 show LM_CMP_Ult = "ult"
725 show LM_CMP_Ule = "ule"
726 show LM_CMP_Sgt = "sgt"
727 show LM_CMP_Sge = "sge"
728 show LM_CMP_Slt = "slt"
729 show LM_CMP_Sle = "sle"
730 show LM_CMP_Feq = "oeq"
731 show LM_CMP_Fne = "une"
732 show LM_CMP_Fgt = "ogt"
733 show LM_CMP_Fge = "oge"
734 show LM_CMP_Flt = "olt"
735 show LM_CMP_Fle = "ole"
736
737
738 -- | Llvm cast operations.
739 data LlvmCastOp
740 = LM_Trunc -- ^ Integer truncate
741 | LM_Zext -- ^ Integer extend (zero fill)
742 | LM_Sext -- ^ Integer extend (sign fill)
743 | LM_Fptrunc -- ^ Float truncate
744 | LM_Fpext -- ^ Float extend
745 | LM_Fptoui -- ^ Float to unsigned Integer
746 | LM_Fptosi -- ^ Float to signed Integer
747 | LM_Uitofp -- ^ Unsigned Integer to Float
748 | LM_Sitofp -- ^ Signed Int to Float
749 | LM_Ptrtoint -- ^ Pointer to Integer
750 | LM_Inttoptr -- ^ Integer to Pointer
751 | LM_Bitcast -- ^ Cast between types where no bit manipulation is needed
752 deriving (Eq)
753
754 instance Show LlvmCastOp where
755 show LM_Trunc = "trunc"
756 show LM_Zext = "zext"
757 show LM_Sext = "sext"
758 show LM_Fptrunc = "fptrunc"
759 show LM_Fpext = "fpext"
760 show LM_Fptoui = "fptoui"
761 show LM_Fptosi = "fptosi"
762 show LM_Uitofp = "uitofp"
763 show LM_Sitofp = "sitofp"
764 show LM_Ptrtoint = "ptrtoint"
765 show LM_Inttoptr = "inttoptr"
766 show LM_Bitcast = "bitcast"
767
768
769 -- -----------------------------------------------------------------------------
770 -- * Floating point conversion
771 --
772
773 -- | Convert a Haskell Double to an LLVM hex encoded floating point form. In
774 -- Llvm float literals can be printed in a big-endian hexadecimal format,
775 -- regardless of underlying architecture.
776 dToStr :: Double -> String
777 dToStr d
778 = let bs = doubleToBytes d
779 hex d' = case showHex d' "" of
780 [] -> error "dToStr: too few hex digits for float"
781 [x] -> ['0',x]
782 [x,y] -> [x,y]
783 _ -> error "dToStr: too many hex digits for float"
784
785 str = map toUpper $ concat . fixEndian . (map hex) $ bs
786 in "0x" ++ str
787
788 -- | Convert a Haskell Float to an LLVM hex encoded floating point form.
789 -- LLVM uses the same encoding for both floats and doubles (16 digit hex
790 -- string) but floats must have the last half all zeroes so it can fit into
791 -- a float size type.
792 {-# NOINLINE fToStr #-}
793 fToStr :: Float -> String
794 fToStr = (dToStr . realToFrac)
795
796 -- | Reverse or leave byte data alone to fix endianness on this target.
797 fixEndian :: [a] -> [a]
798 #ifdef WORDS_BIGENDIAN
799 fixEndian = id
800 #else
801 fixEndian = reverse
802 #endif
803