llvm.org GIT mirror llvm / 3dfb3cf
Fix whitespace to be more consistent with AsmPrinter's style. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@104962 91177308-0d34-0410-b5e6-96231b3b80d8 Dan Gohman 9 years ago
12 changed file(s) with 157 addition(s) and 157 deletion(s). Raw diff Collapse all Expand all
403403
404404
405405

                  
                
406 i8* %llvm.eh.exception( )
406 i8* %llvm.eh.exception()
407407
408408
409409

This intrinsic returns a pointer to the exception structure.

517517
518518
519519

                  
                
520 i8* %llvm.eh.sjlj.lsda( )
520 i8* %llvm.eh.sjlj.lsda()
521521
522522
523523

Used for SJLJ based exception handling, the

802802 ret void
803803 }
804804 define void @bar() {
805 call void @foo( )
805 call void @foo()
806806 ret void
807807 }
808808
24742474 supported). The following is the syntax for constant expressions:

24752475
24762476
2477
trunc ( CST to TYPE )
2477
trunc (CST to TYPE)
24782478
Truncate a constant to another type. The bit size of CST must be larger
24792479 than the bit size of TYPE. Both types must be integers.
24802480
2481
zext ( CST to TYPE )
2481
zext (CST to TYPE)
24822482
Zero extend a constant to another type. The bit size of CST must be
24832483 smaller or equal to the bit size of TYPE. Both types must be
24842484 integers.
24852485
2486
sext ( CST to TYPE )
2486
sext (CST to TYPE)
24872487
Sign extend a constant to another type. The bit size of CST must be
24882488 smaller or equal to the bit size of TYPE. Both types must be
24892489 integers.
24902490
2491
fptrunc ( CST to TYPE )
2491
fptrunc (CST to TYPE)
24922492
Truncate a floating point constant to another floating point type. The
24932493 size of CST must be larger than the size of TYPE. Both types must be
24942494 floating point.
24952495
2496
fpext ( CST to TYPE )
2496
fpext (CST to TYPE)
24972497
Floating point extend a constant to another type. The size of CST must be
24982498 smaller or equal to the size of TYPE. Both types must be floating
24992499 point.
25002500
2501
fptoui ( CST to TYPE )
2501
fptoui (CST to TYPE)
25022502
Convert a floating point constant to the corresponding unsigned integer
25032503 constant. TYPE must be a scalar or vector integer type. CST must be of
25042504 scalar or vector floating point type. Both CST and TYPE must be scalars,
25052505 or vectors of the same number of elements. If the value won't fit in the
25062506 integer type, the results are undefined.
25072507
2508
fptosi ( CST to TYPE )
2508
fptosi (CST to TYPE)
25092509
Convert a floating point constant to the corresponding signed integer
25102510 constant. TYPE must be a scalar or vector integer type. CST must be of
25112511 scalar or vector floating point type. Both CST and TYPE must be scalars,
25122512 or vectors of the same number of elements. If the value won't fit in the
25132513 integer type, the results are undefined.
25142514
2515
uitofp ( CST to TYPE )
2515
uitofp (CST to TYPE)
25162516
Convert an unsigned integer constant to the corresponding floating point
25172517 constant. TYPE must be a scalar or vector floating point type. CST must be
25182518 of scalar or vector integer type. Both CST and TYPE must be scalars, or
25192519 vectors of the same number of elements. If the value won't fit in the
25202520 floating point type, the results are undefined.
25212521
2522
sitofp ( CST to TYPE )
2522
sitofp (CST to TYPE)
25232523
Convert a signed integer constant to the corresponding floating point
25242524 constant. TYPE must be a scalar or vector floating point type. CST must be
25252525 of scalar or vector integer type. Both CST and TYPE must be scalars, or
25262526 vectors of the same number of elements. If the value won't fit in the
25272527 floating point type, the results are undefined.
25282528
2529
ptrtoint ( CST to TYPE )
2529
ptrtoint (CST to TYPE)
25302530
Convert a pointer typed constant to the corresponding integer constant
25312531 TYPE must be an integer type. CST must be of pointer
25322532 type. The CST value is zero extended, truncated, or unchanged to
25332533 make it fit in TYPE.
25342534
2535
inttoptr ( CST to TYPE )
2535
inttoptr (CST to TYPE)
25362536
Convert a integer constant to a pointer constant. TYPE must be a pointer
25372537 type. CST must be of integer type. The CST value is zero extended,
25382538 truncated, or unchanged to make it fit in a pointer size. This one is
25392539 really dangerous!
25402540
2541
bitcast ( CST to TYPE )
2541
bitcast (CST to TYPE)
25422542
Convert a constant, CST, to another TYPE. The constraints of the operands
25432543 are the same as those for the bitcast
25442544 instruction.
25452545
2546
getelementptr ( CSTPTR, IDX0, IDX1, ... )
2547
getelementptr inbounds ( CSTPTR, IDX0, IDX1, ... )
2546
getelementptr (CSTPTR, IDX0, IDX1, ...)
2547
getelementptr inbounds (CSTPTR, IDX0, IDX1, ...)
25482548
Perform the getelementptr operation on
25492549 constants. As with the getelementptr
25502550 instruction, the index list may have zero or more indexes, which are
25512551 required to make sense for the type of "CSTPTR".
25522552
2553
select ( COND, VAL1, VAL2 )
2553
select (COND, VAL1, VAL2)
25542554
Perform the select operation on constants.
25552555
2556
icmp COND ( VAL1, VAL2 )
2556
icmp COND (VAL1, VAL2)
25572557
Performs the icmp operation on constants.
25582558
2559
fcmp COND ( VAL1, VAL2 )
2559
fcmp COND (VAL1, VAL2)
25602560
Performs the fcmp operation on constants.
25612561
2562
extractelement ( VAL, IDX )
2562
extractelement (VAL, IDX)
25632563
Perform the extractelement operation on
25642564 constants.
25652565
2566
insertelement ( VAL, ELT, IDX )
2566
insertelement (VAL, ELT, IDX)
25672567
Perform the insertelement operation on
25682568 constants.
25692569
2570
shufflevector ( VEC1, VEC2, IDXMASK )
2570
shufflevector (VEC1, VEC2, IDXMASK)
25712571
Perform the shufflevector operation on
25722572 constants.
25732573
2574
OPCODE ( LHS, RHS )
2574
OPCODE (LHS, RHS)
25752575
Perform the specified operation of the LHS and RHS constants. OPCODE may
25762576 be any of the binary
25772577 or bitwise binary operations. The constraints
59915991
59925992
Syntax:
59935993

                  
                
5994 declare i64 @llvm.readcyclecounter( )
5994 declare i64 @llvm.readcyclecounter()
59955995
59965996
59975997
Overview:
69376937

                  
                
69386938 %tramp = alloca [10 x i8], align 4 ; size and alignment only correct for X86
69396939 %tramp1 = getelementptr [10 x i8]* %tramp, i32 0, i32 0
6940 %p = call i8* @llvm.init.trampoline( i8* %tramp1, i8* bitcast (i32 (i8* nest , i32, i32)* @f to i8*), i8* %nval )
6940 %p = call i8* @llvm.init.trampoline(i8* %tramp1, i8* bitcast (i32 (i8* nest , i32, i32)* @f to i8*), i8* %nval)
69416941 %fp = bitcast i8* %p to i32 (i32, i32)*
69426942
69436943
69446944
6945

The call %val = call i32 %fp( i32 %x, i32 %y ) is then equivalent

6946 to %val = call i32 %f( i8* %nval, i32 %x, i32 %y ).

6945

The call %val = call i32 %fp(i32 %x, i32 %y) is then equivalent

6946 to %val = call i32 %f(i8* %nval, i32 %x, i32 %y).

69476947
69486948
69496949
70237023
70247024
Syntax:
70257025

                  
                
7026 declare void @llvm.memory.barrier( i1 <ll>, i1 <ls>, i1 <sl>, i1 <ss>, i1 <device> )
7026 declare void @llvm.memory.barrier(i1 <ll>, i1 <ls>, i1 <sl>, i1 <ss>, i1 <device>)
70277027
70287028
70297029
Overview:
70807080 store i32 4, %ptr
70817081
70827082 %result1 = load i32* %ptr ; yields {i32}:result1 = 4
7083 call void @llvm.memory.barrier( i1 false, i1 true, i1 false, i1 false )
7083 call void @llvm.memory.barrier(i1 false, i1 true, i1 false, i1 false)
70847084 ; guarantee the above finishes
70857085 store i32 8, %ptr ; before this begins
70867086
71007100 support all bit widths however.

71017101
71027102

                  
                
7103 declare i8 @llvm.atomic.cmp.swap.i8.p0i8( i8* <ptr>, i8 <cmp>, i8 <val> )
7104 declare i16 @llvm.atomic.cmp.swap.i16.p0i16( i16* <ptr>, i16 <cmp>, i16 <val> )
7105 declare i32 @llvm.atomic.cmp.swap.i32.p0i32( i32* <ptr>, i32 <cmp>, i32 <val> )
7106 declare i64 @llvm.atomic.cmp.swap.i64.p0i64( i64* <ptr>, i64 <cmp>, i64 <val> )
7103 declare i8 @llvm.atomic.cmp.swap.i8.p0i8(i8* <ptr>, i8 <cmp>, i8 <val>)
7104 declare i16 @llvm.atomic.cmp.swap.i16.p0i16(i16* <ptr>, i16 <cmp>, i16 <val>)
7105 declare i32 @llvm.atomic.cmp.swap.i32.p0i32(i32* <ptr>, i32 <cmp>, i32 <val>)
7106 declare i64 @llvm.atomic.cmp.swap.i64.p0i64(i64* <ptr>, i64 <cmp>, i64 <val>)
71077107
71087108
71097109
Overview:
71327132 store i32 4, %ptr
71337133
71347134 %val1 = add i32 4, 4
7135 %result1 = call i32 @llvm.atomic.cmp.swap.i32.p0i32( i32* %ptr, i32 4, %val1 )
7135 %result1 = call i32 @llvm.atomic.cmp.swap.i32.p0i32(i32* %ptr, i32 4, %val1)
71367136 ; yields {i32}:result1 = 4
71377137 %stored1 = icmp eq i32 %result1, 4 ; yields {i1}:stored1 = true
71387138 %memval1 = load i32* %ptr ; yields {i32}:memval1 = 8
71397139
71407140 %val2 = add i32 1, 1
7141 %result2 = call i32 @llvm.atomic.cmp.swap.i32.p0i32( i32* %ptr, i32 5, %val2 )
7141 %result2 = call i32 @llvm.atomic.cmp.swap.i32.p0i32(i32* %ptr, i32 5, %val2)
71427142 ; yields {i32}:result2 = 8
71437143 %stored2 = icmp eq i32 %result2, 5 ; yields {i1}:stored2 = false
71447144
71587158 integer bit width. Not all targets support all bit widths however.

71597159
71607160

                  
                
7161 declare i8 @llvm.atomic.swap.i8.p0i8( i8* <ptr>, i8 <val> )
7162 declare i16 @llvm.atomic.swap.i16.p0i16( i16* <ptr>, i16 <val> )
7163 declare i32 @llvm.atomic.swap.i32.p0i32( i32* <ptr>, i32 <val> )
7164 declare i64 @llvm.atomic.swap.i64.p0i64( i64* <ptr>, i64 <val> )
7161 declare i8 @llvm.atomic.swap.i8.p0i8(i8* <ptr>, i8 <val>)
7162 declare i16 @llvm.atomic.swap.i16.p0i16(i16* <ptr>, i16 <val>)
7163 declare i32 @llvm.atomic.swap.i32.p0i32(i32* <ptr>, i32 <val>)
7164 declare i64 @llvm.atomic.swap.i64.p0i64(i64* <ptr>, i64 <val>)
71657165
71667166
71677167
Overview:
71887188 store i32 4, %ptr
71897189
71907190 %val1 = add i32 4, 4
7191 %result1 = call i32 @llvm.atomic.swap.i32.p0i32( i32* %ptr, i32 %val1 )
7191 %result1 = call i32 @llvm.atomic.swap.i32.p0i32(i32* %ptr, i32 %val1)
71927192 ; yields {i32}:result1 = 4
71937193 %stored1 = icmp eq i32 %result1, 4 ; yields {i1}:stored1 = true
71947194 %memval1 = load i32* %ptr ; yields {i32}:memval1 = 8
71957195
71967196 %val2 = add i32 1, 1
7197 %result2 = call i32 @llvm.atomic.swap.i32.p0i32( i32* %ptr, i32 %val2 )
7197 %result2 = call i32 @llvm.atomic.swap.i32.p0i32(i32* %ptr, i32 %val2)
71987198 ; yields {i32}:result2 = 8
71997199
72007200 %stored2 = icmp eq i32 %result2, 8 ; yields {i1}:stored2 = true
72167216 any integer bit width. Not all targets support all bit widths however.

72177217
72187218

                  
                
7219 declare i8 @llvm.atomic.load.add.i8.p0i8( i8* <ptr>, i8 <delta> )
7220 declare i16 @llvm.atomic.load.add.i16.p0i16( i16* <ptr>, i16 <delta> )
7221 declare i32 @llvm.atomic.load.add.i32.p0i32( i32* <ptr>, i32 <delta> )
7222 declare i64 @llvm.atomic.load.add.i64.p0i64( i64* <ptr>, i64 <delta> )
7219 declare i8 @llvm.atomic.load.add.i8.p0i8(i8* <ptr>, i8 <delta>)
7220 declare i16 @llvm.atomic.load.add.i16.p0i16(i16* <ptr>, i16 <delta>)
7221 declare i32 @llvm.atomic.load.add.i32.p0i32(i32* <ptr>, i32 <delta>)
7222 declare i64 @llvm.atomic.load.add.i64.p0i64(i64* <ptr>, i64 <delta>)
72237223
72247224
72257225
Overview:
72427242 %mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
72437243 %ptr = bitcast i8* %mallocP to i32*
72447244 store i32 4, %ptr
7245 %result1 = call i32 @llvm.atomic.load.add.i32.p0i32( i32* %ptr, i32 4 )
7245 %result1 = call i32 @llvm.atomic.load.add.i32.p0i32(i32* %ptr, i32 4)
72467246 ; yields {i32}:result1 = 4
7247 %result2 = call i32 @llvm.atomic.load.add.i32.p0i32( i32* %ptr, i32 2 )
7247 %result2 = call i32 @llvm.atomic.load.add.i32.p0i32(i32* %ptr, i32 2)
72487248 ; yields {i32}:result2 = 8
7249 %result3 = call i32 @llvm.atomic.load.add.i32.p0i32( i32* %ptr, i32 5 )
7249 %result3 = call i32 @llvm.atomic.load.add.i32.p0i32(i32* %ptr, i32 5)
72507250 ; yields {i32}:result3 = 10
72517251 %memval1 = load i32* %ptr ; yields {i32}:memval1 = 15
72527252
72677267 support all bit widths however.

72687268
72697269

                  
                
7270 declare i8 @llvm.atomic.load.sub.i8.p0i32( i8* <ptr>, i8 <delta> )
7271 declare i16 @llvm.atomic.load.sub.i16.p0i32( i16* <ptr>, i16 <delta> )
7272 declare i32 @llvm.atomic.load.sub.i32.p0i32( i32* <ptr>, i32 <delta> )
7273 declare i64 @llvm.atomic.load.sub.i64.p0i32( i64* <ptr>, i64 <delta> )
7270 declare i8 @llvm.atomic.load.sub.i8.p0i32(i8* <ptr>, i8 <delta>)
7271 declare i16 @llvm.atomic.load.sub.i16.p0i32(i16* <ptr>, i16 <delta>)
7272 declare i32 @llvm.atomic.load.sub.i32.p0i32(i32* <ptr>, i32 <delta>)
7273 declare i64 @llvm.atomic.load.sub.i64.p0i32(i64* <ptr>, i64 <delta>)
72747274
72757275
72767276
Overview:
72947294 %mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
72957295 %ptr = bitcast i8* %mallocP to i32*
72967296 store i32 8, %ptr
7297 %result1 = call i32 @llvm.atomic.load.sub.i32.p0i32( i32* %ptr, i32 4 )
7297 %result1 = call i32 @llvm.atomic.load.sub.i32.p0i32(i32* %ptr, i32 4)
72987298 ; yields {i32}:result1 = 8
7299 %result2 = call i32 @llvm.atomic.load.sub.i32.p0i32( i32* %ptr, i32 2 )
7299 %result2 = call i32 @llvm.atomic.load.sub.i32.p0i32(i32* %ptr, i32 2)
73007300 ; yields {i32}:result2 = 4
7301 %result3 = call i32 @llvm.atomic.load.sub.i32.p0i32( i32* %ptr, i32 5 )
7301 %result3 = call i32 @llvm.atomic.load.sub.i32.p0i32(i32* %ptr, i32 5)
73027302 ; yields {i32}:result3 = 2
73037303 %memval1 = load i32* %ptr ; yields {i32}:memval1 = -3
73047304
73237323 widths however.

73247324
73257325

                  
                
7326 declare i8 @llvm.atomic.load.and.i8.p0i8( i8* <ptr>, i8 <delta> )
7327 declare i16 @llvm.atomic.load.and.i16.p0i16( i16* <ptr>, i16 <delta> )
7328 declare i32 @llvm.atomic.load.and.i32.p0i32( i32* <ptr>, i32 <delta> )
7329 declare i64 @llvm.atomic.load.and.i64.p0i64( i64* <ptr>, i64 <delta> )
7330
7331
7332

                  
                
7333 declare i8 @llvm.atomic.load.or.i8.p0i8( i8* <ptr>, i8 <delta> )
7334 declare i16 @llvm.atomic.load.or.i16.p0i16( i16* <ptr>, i16 <delta> )
7335 declare i32 @llvm.atomic.load.or.i32.p0i32( i32* <ptr>, i32 <delta> )
7336 declare i64 @llvm.atomic.load.or.i64.p0i64( i64* <ptr>, i64 <delta> )
7337
7338
7339

                  
                
7340 declare i8 @llvm.atomic.load.nand.i8.p0i32( i8* <ptr>, i8 <delta> )
7341 declare i16 @llvm.atomic.load.nand.i16.p0i32( i16* <ptr>, i16 <delta> )
7342 declare i32 @llvm.atomic.load.nand.i32.p0i32( i32* <ptr>, i32 <delta> )
7343 declare i64 @llvm.atomic.load.nand.i64.p0i32( i64* <ptr>, i64 <delta> )
7344
7345
7346

                  
                
7347 declare i8 @llvm.atomic.load.xor.i8.p0i32( i8* <ptr>, i8 <delta> )
7348 declare i16 @llvm.atomic.load.xor.i16.p0i32( i16* <ptr>, i16 <delta> )
7349 declare i32 @llvm.atomic.load.xor.i32.p0i32( i32* <ptr>, i32 <delta> )
7350 declare i64 @llvm.atomic.load.xor.i64.p0i32( i64* <ptr>, i64 <delta> )
7326 declare i8 @llvm.atomic.load.and.i8.p0i8(i8* <ptr>, i8 <delta>)
7327 declare i16 @llvm.atomic.load.and.i16.p0i16(i16* <ptr>, i16 <delta>)
7328 declare i32 @llvm.atomic.load.and.i32.p0i32(i32* <ptr>, i32 <delta>)
7329 declare i64 @llvm.atomic.load.and.i64.p0i64(i64* <ptr>, i64 <delta>)
7330
7331
7332

                  
                
7333 declare i8 @llvm.atomic.load.or.i8.p0i8(i8* <ptr>, i8 <delta>)
7334 declare i16 @llvm.atomic.load.or.i16.p0i16(i16* <ptr>, i16 <delta>)
7335 declare i32 @llvm.atomic.load.or.i32.p0i32(i32* <ptr>, i32 <delta>)
7336 declare i64 @llvm.atomic.load.or.i64.p0i64(i64* <ptr>, i64 <delta>)
7337
7338
7339

                  
                
7340 declare i8 @llvm.atomic.load.nand.i8.p0i32(i8* <ptr>, i8 <delta>)
7341 declare i16 @llvm.atomic.load.nand.i16.p0i32(i16* <ptr>, i16 <delta>)
7342 declare i32 @llvm.atomic.load.nand.i32.p0i32(i32* <ptr>, i32 <delta>)
7343 declare i64 @llvm.atomic.load.nand.i64.p0i32(i64* <ptr>, i64 <delta>)
7344
7345
7346

                  
                
7347 declare i8 @llvm.atomic.load.xor.i8.p0i32(i8* <ptr>, i8 <delta>)
7348 declare i16 @llvm.atomic.load.xor.i16.p0i32(i16* <ptr>, i16 <delta>)
7349 declare i32 @llvm.atomic.load.xor.i32.p0i32(i32* <ptr>, i32 <delta>)
7350 declare i64 @llvm.atomic.load.xor.i64.p0i32(i64* <ptr>, i64 <delta>)
73517351
73527352
73537353
Overview:
73727372 %mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
73737373 %ptr = bitcast i8* %mallocP to i32*
73747374 store i32 0x0F0F, %ptr
7375 %result0 = call i32 @llvm.atomic.load.nand.i32.p0i32( i32* %ptr, i32 0xFF )
7375 %result0 = call i32 @llvm.atomic.load.nand.i32.p0i32(i32* %ptr, i32 0xFF)
73767376 ; yields {i32}:result0 = 0x0F0F
7377 %result1 = call i32 @llvm.atomic.load.and.i32.p0i32( i32* %ptr, i32 0xFF )
7377 %result1 = call i32 @llvm.atomic.load.and.i32.p0i32(i32* %ptr, i32 0xFF)
73787378 ; yields {i32}:result1 = 0xFFFFFFF0
7379 %result2 = call i32 @llvm.atomic.load.or.i32.p0i32( i32* %ptr, i32 0F )
7379 %result2 = call i32 @llvm.atomic.load.or.i32.p0i32(i32* %ptr, i32 0F)
73807380 ; yields {i32}:result2 = 0xF0
7381 %result3 = call i32 @llvm.atomic.load.xor.i32.p0i32( i32* %ptr, i32 0F )
7381 %result3 = call i32 @llvm.atomic.load.xor.i32.p0i32(i32* %ptr, i32 0F)
73827382 ; yields {i32}:result3 = FF
73837383 %memval1 = load i32* %ptr ; yields {i32}:memval1 = F0
73847384
74027402 address spaces. Not all targets support all bit widths however.

74037403
74047404

                  
                
7405 declare i8 @llvm.atomic.load.max.i8.p0i8( i8* <ptr>, i8 <delta> )
7406 declare i16 @llvm.atomic.load.max.i16.p0i16( i16* <ptr>, i16 <delta> )
7407 declare i32 @llvm.atomic.load.max.i32.p0i32( i32* <ptr>, i32 <delta> )
7408 declare i64 @llvm.atomic.load.max.i64.p0i64( i64* <ptr>, i64 <delta> )
7409
7410
7411

                  
                
7412 declare i8 @llvm.atomic.load.min.i8.p0i8( i8* <ptr>, i8 <delta> )
7413 declare i16 @llvm.atomic.load.min.i16.p0i16( i16* <ptr>, i16 <delta> )
7414 declare i32 @llvm.atomic.load.min.i32.p0i32( i32* <ptr>, i32 <delta> )
7415 declare i64 @llvm.atomic.load.min.i64.p0i64( i64* <ptr>, i64 <delta> )
7416
7417
7418

                  
                
7419 declare i8 @llvm.atomic.load.umax.i8.p0i8( i8* <ptr>, i8 <delta> )
7420 declare i16 @llvm.atomic.load.umax.i16.p0i16( i16* <ptr>, i16 <delta> )
7421 declare i32 @llvm.atomic.load.umax.i32.p0i32( i32* <ptr>, i32 <delta> )
7422 declare i64 @llvm.atomic.load.umax.i64.p0i64( i64* <ptr>, i64 <delta> )
7423
7424
7425

                  
                
7426 declare i8 @llvm.atomic.load.umin.i8.p0i8( i8* <ptr>, i8 <delta> )
7427 declare i16 @llvm.atomic.load.umin.i16.p0i16( i16* <ptr>, i16 <delta> )
7428 declare i32 @llvm.atomic.load.umin.i32.p0i32( i32* <ptr>, i32 <delta> )
7429 declare i64 @llvm.atomic.load.umin.i64.p0i64( i64* <ptr>, i64 <delta> )
7405 declare i8 @llvm.atomic.load.max.i8.p0i8(i8* <ptr>, i8 <delta>)
7406 declare i16 @llvm.atomic.load.max.i16.p0i16(i16* <ptr>, i16 <delta>)
7407 declare i32 @llvm.atomic.load.max.i32.p0i32(i32* <ptr>, i32 <delta>)
7408 declare i64 @llvm.atomic.load.max.i64.p0i64(i64* <ptr>, i64 <delta>)
7409
7410
7411

                  
                
7412 declare i8 @llvm.atomic.load.min.i8.p0i8(i8* <ptr>, i8 <delta>)
7413 declare i16 @llvm.atomic.load.min.i16.p0i16(i16* <ptr>, i16 <delta>)
7414 declare i32 @llvm.atomic.load.min.i32.p0i32(i32* <ptr>, i32 <delta>)
7415 declare i64 @llvm.atomic.load.min.i64.p0i64(i64* <ptr>, i64 <delta>)
7416
7417
7418

                  
                
7419 declare i8 @llvm.atomic.load.umax.i8.p0i8(i8* <ptr>, i8 <delta>)
7420 declare i16 @llvm.atomic.load.umax.i16.p0i16(i16* <ptr>, i16 <delta>)
7421 declare i32 @llvm.atomic.load.umax.i32.p0i32(i32* <ptr>, i32 <delta>)
7422 declare i64 @llvm.atomic.load.umax.i64.p0i64(i64* <ptr>, i64 <delta>)
7423
7424
7425

                  
                
7426 declare i8 @llvm.atomic.load.umin.i8.p0i8(i8* <ptr>, i8 <delta>)
7427 declare i16 @llvm.atomic.load.umin.i16.p0i16(i16* <ptr>, i16 <delta>)
7428 declare i32 @llvm.atomic.load.umin.i32.p0i32(i32* <ptr>, i32 <delta>)
7429 declare i64 @llvm.atomic.load.umin.i64.p0i64(i64* <ptr>, i64 <delta>)
74307430
74317431
74327432
Overview:
74517451 %mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
74527452 %ptr = bitcast i8* %mallocP to i32*
74537453 store i32 7, %ptr
7454 %result0 = call i32 @llvm.atomic.load.min.i32.p0i32( i32* %ptr, i32 -2 )
7454 %result0 = call i32 @llvm.atomic.load.min.i32.p0i32(i32* %ptr, i32 -2)
74557455 ; yields {i32}:result0 = 7
7456 %result1 = call i32 @llvm.atomic.load.max.i32.p0i32( i32* %ptr, i32 8 )
7456 %result1 = call i32 @llvm.atomic.load.max.i32.p0i32(i32* %ptr, i32 8)
74577457 ; yields {i32}:result1 = -2
7458 %result2 = call i32 @llvm.atomic.load.umin.i32.p0i32( i32* %ptr, i32 10 )
7458 %result2 = call i32 @llvm.atomic.load.umin.i32.p0i32(i32* %ptr, i32 10)
74597459 ; yields {i32}:result2 = 8
7460 %result3 = call i32 @llvm.atomic.load.umax.i32.p0i32( i32* %ptr, i32 30 )
7460 %result3 = call i32 @llvm.atomic.load.umax.i32.p0i32(i32* %ptr, i32 30)
74617461 ; yields {i32}:result3 = 8
74627462 %memval1 = load i32* %ptr ; yields {i32}:memval1 = 30
74637463
76127612
76137613
Syntax:
76147614

                  
                
7615 declare void @llvm.var.annotation(i8* <val>, i8* <str>, i8* <str>, i32 <int> )
7615 declare void @llvm.var.annotation(i8* <val>, i8* <str>, i8* <str>, i32 <int>)
76167616
76177617
76187618
Overview:
76437643 any integer bit width.

76447644
76457645

                  
                
7646 declare i8 @llvm.annotation.i8(i8 <val>, i8* <str>, i8* <str>, i32 <int> )
7647 declare i16 @llvm.annotation.i16(i16 <val>, i8* <str>, i8* <str>, i32 <int> )
7648 declare i32 @llvm.annotation.i32(i32 <val>, i8* <str>, i8* <str>, i32 <int> )
7649 declare i64 @llvm.annotation.i64(i64 <val>, i8* <str>, i8* <str>, i32 <int> )
7650 declare i256 @llvm.annotation.i256(i256 <val>, i8* <str>, i8* <str>, i32 <int> )
7646 declare i8 @llvm.annotation.i8(i8 <val>, i8* <str>, i8* <str>, i32 <int>)
7647 declare i16 @llvm.annotation.i16(i16 <val>, i8* <str>, i8* <str>, i32 <int>)
7648 declare i32 @llvm.annotation.i32(i32 <val>, i8* <str>, i8* <str>, i32 <int>)
7649 declare i64 @llvm.annotation.i64(i64 <val>, i8* <str>, i8* <str>, i32 <int>)
7650 declare i256 @llvm.annotation.i256(i256 <val>, i8* <str>, i8* <str>, i32 <int>)
76517651
76527652
76537653
Overview:
77017701
77027702
Syntax:
77037703

                  
                
7704 declare void @llvm.stackprotector( i8* <guard>, i8** <slot> )
7704 declare void @llvm.stackprotector(i8* <guard>, i8** <slot>)
77057705
77067706
77077707
Overview:
77357735
77367736
Syntax:
77377737

                  
                
7738 declare i32 @llvm.objectsize.i32( i8* <object>, i1 <type> )
7739 declare i64 @llvm.objectsize.i64( i8* <object>, i1 <type> )
7738 declare i32 @llvm.objectsize.i32(i8* <object>, i1 <type>)
7739 declare i64 @llvm.objectsize.i64(i8* <object>, i1 <type>)
77407740
77417741
77427742
Overview:
781781
782782
783783

                  
                
784 void %llvm.dbg.declare( { } *, metadata )
784 void %llvm.dbg.declare({ }*, metadata)
785785
786786
787787

This intrinsic provides information about a local element (ex. variable.) The

799799
800800
801801

                  
                
802 void %llvm.dbg.value( metadata, i64, metadata )
802 void %llvm.dbg.value(metadata, i64, metadata)
803803
804804
805805

This intrinsic provides information when a user source variable is set to a

573573 Read function definition:
574574 define double @bar(double %a) {
575575 entry:
576 %calltmp = call double @foo( double %a, double 4.000000e+00 )
577 %calltmp1 = call double @bar( double 3.133700e+04 )
576 %calltmp = call double @foo(double %a, double 4.000000e+00)
577 %calltmp1 = call double @bar(double 3.133700e+04)
578578 %addtmp = fadd double %calltmp, %calltmp1
579579 ret double %addtmp
580580 }
595595 Read top-level expression:
596596 define double @""() {
597597 entry:
598 %calltmp = call double @cos( double 1.234000e+00 )
598 %calltmp = call double @cos(double 1.234000e+00)
599599 ret double %calltmp
600600 }
601601
628628
629629 define double @bar(double %a) {
630630 entry:
631 %calltmp = call double @foo( double %a, double 4.000000e+00 )
632 %calltmp1 = call double @bar( double 3.133700e+04 )
631 %calltmp = call double @foo(double %a, double 4.000000e+00)
632 %calltmp1 = call double @bar(double 3.133700e+04)
633633 %addtmp = fadd double %calltmp, %calltmp1
634634 ret double %addtmp
635635 }
638638
639639 define double @""() {
640640 entry:
641 %calltmp = call double @cos( double 1.234000e+00 )
641 %calltmp = call double @cos(double 1.234000e+00)
642642 ret double %calltmp
643643 }
644644
370370 ready> testfunc(4, 10);
371371 define double @""() {
372372 entry:
373 %calltmp = call double @testfunc( double 4.000000e+00, double 1.000000e+01 )
373 %calltmp = call double @testfunc(double 4.000000e+00, double 1.000000e+01)
374374 ret double %calltmp
375375 }
376376
409409 Read function definition:
410410 define double @foo(double %x) {
411411 entry:
412 %calltmp = call double @sin( double %x )
412 %calltmp = call double @sin(double %x)
413413 %multmp = fmul double %calltmp, %calltmp
414 %calltmp2 = call double @cos( double %x )
414 %calltmp2 = call double @cos(double %x)
415415 %multmp4 = fmul double %calltmp2, %calltmp2
416416 %addtmp = fadd double %multmp, %multmp4
417417 ret double %addtmp
675675 loop: ; preds = %loop, %entry
676676 %i = phi double [ 1.000000e+00, %entry ], [ %nextvar, %loop ]
677677 ; body
678 %calltmp = call double @putchard( double 4.200000e+01 )
678 %calltmp = call double @putchard(double 4.200000e+01)
679679 ; increment
680680 %nextvar = fadd double %i, 1.000000e+00
681681
557557 else: ; preds = %entry
558558 %x3 = load double* %x1
559559 %subtmp = fsub double %x3, 1.000000e+00
560 %calltmp = call double @fib( double %subtmp )
560 %calltmp = call double @fib(double %subtmp)
561561 %x4 = load double* %x1
562562 %subtmp5 = fsub double %x4, 2.000000e+00
563 %calltmp6 = call double @fib( double %subtmp5 )
563 %calltmp6 = call double @fib(double %subtmp5)
564564 %addtmp = fadd double %calltmp, %calltmp6
565565 br label %ifcont
566566
595595
596596 else:
597597 %subtmp = fsub double %x, 1.000000e+00
598 %calltmp = call double @fib( double %subtmp )
598 %calltmp = call double @fib(double %subtmp)
599599 %subtmp5 = fsub double %x, 2.000000e+00
600 %calltmp6 = call double @fib( double %subtmp5 )
600 %calltmp6 = call double @fib(double %subtmp5)
601601 %addtmp = fadd double %calltmp, %calltmp6
602602 br label %ifcont
603603
625625
626626 else:
627627 %subtmp = fsub double %x, 1.000000e+00
628 %calltmp = call double @fib( double %subtmp )
628 %calltmp = call double @fib(double %subtmp)
629629 %subtmp5 = fsub double %x, 2.000000e+00
630 %calltmp6 = call double @fib( double %subtmp5 )
630 %calltmp6 = call double @fib(double %subtmp5)
631631 %addtmp = fadd double %calltmp, %calltmp6
632632 ret double %addtmp
633633
523523 Read function definition:
524524 define double @bar(double %a) {
525525 entry:
526 %calltmp = call double @foo( double %a, double 4.000000e+00 )
527 %calltmp1 = call double @bar( double 3.133700e+04 )
526 %calltmp = call double @foo(double %a, double 4.000000e+00)
527 %calltmp1 = call double @bar(double 3.133700e+04)
528528 %addtmp = fadd double %calltmp, %calltmp1
529529 ret double %addtmp
530530 }
545545 Read top-level expression:
546546 define double @""() {
547547 entry:
548 %calltmp = call double @cos( double 1.234000e+00 )
548 %calltmp = call double @cos(double 1.234000e+00)
549549 ret double %calltmp
550550 }
551551
578578
579579 define double @bar(double %a) {
580580 entry:
581 %calltmp = call double @foo( double %a, double 4.000000e+00 )
582 %calltmp1 = call double @bar( double 3.133700e+04 )
581 %calltmp = call double @foo(double %a, double 4.000000e+00)
582 %calltmp1 = call double @bar(double 3.133700e+04)
583583 %addtmp = fadd double %calltmp, %calltmp1
584584 ret double %addtmp
585585 }
588588
589589 define double @""() {
590590 entry:
591 %calltmp = call double @cos( double 1.234000e+00 )
591 %calltmp = call double @cos(double 1.234000e+00)
592592 ret double %calltmp
593593 }
594594
386386 ready> testfunc(4, 10);
387387 define double @""() {
388388 entry:
389 %calltmp = call double @testfunc( double 4.000000e+00, double 1.000000e+01 )
389 %calltmp = call double @testfunc(double 4.000000e+00, double 1.000000e+01)
390390 ret double %calltmp
391391 }
392392
425425 Read function definition:
426426 define double @foo(double %x) {
427427 entry:
428 %calltmp = call double @sin( double %x )
428 %calltmp = call double @sin(double %x)
429429 %multmp = fmul double %calltmp, %calltmp
430 %calltmp2 = call double @cos( double %x )
430 %calltmp2 = call double @cos(double %x)
431431 %multmp4 = fmul double %calltmp2, %calltmp2
432432 %addtmp = fadd double %multmp, %multmp4
433433 ret double %addtmp
650650 loop: ; preds = %loop, %entry
651651 %i = phi double [ 1.000000e+00, %entry ], [ %nextvar, %loop ]
652652 ; body
653 %calltmp = call double @putchard( double 4.200000e+01 )
653 %calltmp = call double @putchard(double 4.200000e+01)
654654 ; increment
655655 %nextvar = fadd double %i, 1.000000e+00
656656
581581 else: ; preds = %entry
582582 %x3 = load double* %x1
583583 %subtmp = fsub double %x3, 1.000000e+00
584 %calltmp = call double @fib( double %subtmp )
584 %calltmp = call double @fib(double %subtmp)
585585 %x4 = load double* %x1
586586 %subtmp5 = fsub double %x4, 2.000000e+00
587 %calltmp6 = call double @fib( double %subtmp5 )
587 %calltmp6 = call double @fib(double %subtmp5)
588588 %addtmp = fadd double %calltmp, %calltmp6
589589 br label %ifcont
590590
619619
620620 else:
621621 %subtmp = fsub double %x, 1.000000e+00
622 %calltmp = call double @fib( double %subtmp )
622 %calltmp = call double @fib(double %subtmp)
623623 %subtmp5 = fsub double %x, 2.000000e+00
624 %calltmp6 = call double @fib( double %subtmp5 )
624 %calltmp6 = call double @fib(double %subtmp5)
625625 %addtmp = fadd double %calltmp, %calltmp6
626626 br label %ifcont
627627
649649
650650 else:
651651 %subtmp = fsub double %x, 1.000000e+00
652 %calltmp = call double @fib( double %subtmp )
652 %calltmp = call double @fib(double %subtmp)
653653 %subtmp5 = fsub double %x, 2.000000e+00
654 %calltmp6 = call double @fib( double %subtmp5 )
654 %calltmp6 = call double @fib(double %subtmp5)
655655 %addtmp = fadd double %calltmp, %calltmp6
656656 ret double %addtmp
657657