intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-02-03 10:39:35 +08:00
Code Issues Packages Projects Releases Wiki Activity
34,799 Commits 74 Branches 2,130 Tags
91fcddb5cc0ef3b25c359f69b80858b2e7e14100
Commit Graph

45 Commits

Author SHA1 Message Date
Chris Lattner
e73e4322d6 Implement break and continue. Patch by Anders Carlsson! 
llvm-svn: 39927
 2007-07-16 21:28:45 +00:00
Chris Lattner
388cf760e2 implement codegen support for implicit casts. 
llvm-svn: 39831
 2007-07-13 20:25:53 +00:00
Chris Lattner
6e9d9b350e "Codegen for Character Literals and Conditional Operator 
Both in one patch, and the test case that Chris didn't commit last
time is in there too...

I'll split the patch up if somebody wants it split."

Patch by Keith Bauer.

llvm-svn: 39796
 2007-07-13 05:18:11 +00:00
Chris Lattner
d2b88ab313 Implement codegen for + and - with pointers. Patch contributed by 
Keith Bauer.

llvm-svn: 39793
 2007-07-13 03:05:23 +00:00
Chris Lattner
dcca487cfa implement codegen support for pre/post inc/dec. 
llvm-svn: 39765
 2007-07-11 23:43:46 +00:00
Chris Lattner
a779b3df28 implement codegen support for rvalue-only vector subscripts, such as: 
float4 test(void);
float test2() {
  return test()[1];
}

llvm-svn: 39725
 2007-07-10 21:58:36 +00:00
Chris Lattner
08c4b9ffec Add support for codegen'ing vector subscripts, at least when they are lvalues. 
llvm-svn: 39724
 2007-07-10 21:17:59 +00:00
Chris Lattner
2ada32ed7d implement codegen support for FP literals 
llvm-svn: 39718
 2007-07-09 23:03:16 +00:00
Chris Lattner
47c247e7bf add codegen support for <<= and >>=. 
llvm-svn: 39713
 2007-06-29 17:26:27 +00:00
Chris Lattner
b25a94383a Implement the rest of the compound assignment operators, except shifts. 
llvm-svn: 39712
 2007-06-29 17:03:06 +00:00
Chris Lattner
cd215f00ee refactor some code, implement -= 
llvm-svn: 39711
 2007-06-29 16:52:55 +00:00
Chris Lattner
9369a563b4 Rename ArithAssignBinaryOperator -> CompoundAssignOperator, implement 
codegen support for +=.

llvm-svn: 39710
 2007-06-29 16:31:29 +00:00
Chris Lattner
54fb19efaa implement support for struct and complex returns. 
llvm-svn: 39674
 2007-06-22 22:02:34 +00:00
Chris Lattner
e9a6453ded add some infrastructure for codegen'ing complex numbers. implement addition 
of complex.  We now produce optimal code for:

void test(_Complex float *Y) {
  *Y = *Y + *Y;
}

$ clang -emit-llvm cg.c | llvm-as | opt -std-compile-opts | llc -march=x86-64
...
_test:
        movss (%rdi), %xmm0
        addss %xmm0, %xmm0
        movss 4(%rdi), %xmm1
        movss %xmm0, (%rdi)
        addss %xmm1, %xmm1
        movss %xmm1, 4(%rdi)
        ret

llvm-svn: 39673
 2007-06-22 21:44:33 +00:00
Chris Lattner
f033c147c9 remove location tracking for target info 
llvm-svn: 39671
 2007-06-22 19:05:19 +00:00
Chris Lattner
09153c0a8c Build enough support for aggregates to be able to compile this: 
void test(int A, _Complex float Y) {
  _Complex float X;
  X = X;

}

llvm-svn: 39669
 2007-06-22 18:48:09 +00:00
Chris Lattner
1fde0b345b implement codegen of the relational operations 
One major FIXME though.

llvm-svn: 39666
 2007-06-20 18:30:55 +00:00
Chris Lattner
273c63d450 Implement the equality operators for simple types 
llvm-svn: 39665
 2007-06-20 18:02:30 +00:00
Chris Lattner
2ccb73bc8b Refactor CodeGenTypes out to CodeGenModule so it can be used for functions 
and globals.

llvm-svn: 39661
 2007-06-16 00:16:26 +00:00
Chris Lattner
2052bc8107 Split type analysis out to its own file, now the integer constant expr evaluation 
is ready.

llvm-svn: 39660
 2007-06-16 00:12:05 +00:00
Chris Lattner
23b7eb677d Finally bite the bullet and make the major change: split the clang namespace 
out of the llvm namespace.  This makes the clang namespace be a sibling of
llvm instead of being a child.

The good thing about this is that it makes many things unambiguous.  The
bad things is that many things in the llvm namespace (notably data structures
like smallvector) now require an llvm:: qualifier.  IMO, libsystem and libsupport
should be split out of llvm into their own namespace in the future, which will fix
this issue.

llvm-svn: 39659
 2007-06-15 23:05:46 +00:00
Chris Lattner
2b228c95aa implement codegen of calls. We can now compile: 
double foo( int (*FP)(int, int, int)) {
  return FP(1, 2, 3);
}

to:

define double @foo(i32 (i32, i32, i32)* %FP) {
entry:
        %call = tail call i32 %FP( i32 1, i32 2, i32 3 )
        %conv = sitofp i32 %call to double
        ret double %conv
}

llvm-svn: 39658
 2007-06-15 21:34:29 +00:00
Chris Lattner
53621a535d Implement support for formal arguments. We can now compile this: 
int test(int X, short Y, float Z) {
  return (int)(X*Y+Z);
}

to:

define i32 @test(i32 %X, i16 %Y, float %Z) {
entry:
        %promote = sext i16 %Y to i32           ; <i32> [#uses=1]
        %mul = mul i32 %promote, %X             ; <i32> [#uses=1]
        %promote3 = sitofp i32 %mul to float            ; <float> [#uses=1]
        %add = add float %promote3, %Z          ; <float> [#uses=1]
        %conv = fptosi float %add to i32                ; <i32> [#uses=1]
        ret i32 %conv
}

with:

$ clang -emit-llvm t.c | llvm-as | opt -std-compile-opts | llvm-dis

llvm-svn: 39652
 2007-06-13 20:44:40 +00:00
Chris Lattner
45bb914249 Convert argument types over, which works for trivial scalars. 
llvm-svn: 39625
 2007-06-09 02:28:57 +00:00
Chris Lattner
1ad38f8fee codegen all declarators in a declstmt, allowing us to successfully codegen 
stuff like:

void test() {
  int *X, Y, *Z[14];

  X[Y] = 4;
}

llvm-svn: 39624
 2007-06-09 01:20:56 +00:00
Chris Lattner
d9d2fb1420 Implement array subscripts for non-vla types. 
llvm-svn: 39622
 2007-06-08 23:31:14 +00:00
Chris Lattner
4347e369b4 implement codegen of string literals. 
llvm-svn: 39597
 2007-06-06 04:54:52 +00:00
Chris Lattner
cf106ab42a implement support for casts to/from pointers. 
llvm-svn: 39595
 2007-06-06 04:05:39 +00:00
Chris Lattner
8394d795c3 implement codegen of a bunch more loop constructs and most expressions 
llvm-svn: 39593
 2007-06-05 20:53:16 +00:00
Chris Lattner
946aa31f02 implement codegen of while stmts and lvalue evaluation of paren exprs :) 
llvm-svn: 39582
 2007-06-05 03:59:43 +00:00
Chris Lattner
cf25024828 Implement EmitUsualArithmeticConversions, so we can add shorts to floats and 
ints to long long etc.  For int to longlong, we now get:

        %tmp = load i64* %F             ; <i64> [#uses=1]
        %tmp1 = load i32* %D            ; <i32> [#uses=1]
        %promote = sext i32 %tmp1 to i64                ; <i64> [#uses=1]
        %tmp2 = add i64 %tmp, %promote          ; <i64> [#uses=0]

llvm-svn: 39576
 2007-06-03 02:02:44 +00:00
Chris Lattner
6db1fb845a implement a first hack at codegen'ing the usual unary conversions. 
This allows us to compile:

int func() {
  int A[10];
  if (!A) {

to:

define i32 @func() {
entry:
        %A = alloca [10 x i32]          ; <[10 x i32]*> [#uses=1]
        %arraydecay = getelementptr [10 x i32]* %A, i32 0, i32 0                ; <i32*> [#uses=1]
        %tobool = icmp ne i32* %arraydecay, null                ; <i1> [#uses=1]
        %lnot = xor i1 %tobool, true            ; <i1> [#uses=1]
        br i1 %lnot, label %ifthen, label %ifend

-Chris

llvm-svn: 39564
 2007-06-02 22:49:07 +00:00
Chris Lattner
2b4e21ac3f Implement translation of pointer, reference and simple array types. We now 
compile:

void foo() {
  int A[10];
  int *P;

into:

entry:
        %A = alloca [10 x i32]          ; <[10 x i32]*> [#uses=0]
        %P = alloca i32*                ; <i32**> [#uses=0]

llvm-svn: 39561
 2007-06-02 19:52:24 +00:00
Chris Lattner
f0106d2578 Refactor EvaluateScalarValueToBool out of if statement emission, so it can 
be shared.

Implement infrastructure for unary operator emission.

Implement basic logical not support.  We now compile:

  register short X;

  if (!X) {

into:

        %tmp = load i16* %X             ; <i16> [#uses=1]
        %tobool = icmp ne i16 %tmp, 0           ; <i1> [#uses=1]
        %lnot = xor i1 %tobool, true            ; <i1> [#uses=1]
        zext i1 %lnot to i32            ; <i32>:0 [#uses=1]
        %tobool1 = icmp ne i32 %0, 0            ; <i1> [#uses=1]
        br i1 %tobool1, label %ifthen, label %ifend

llvm-svn: 39559
 2007-06-02 19:33:17 +00:00
Chris Lattner
d7f58867e5 Implement scaffolding for lvalues. Implement block vardecl lvalues. 
This allows us to translate:

int func() {
  register int X;
  {
    int Y;
    return 1+X+Y;
  }
}

into:

define i32 @func() {
entry:
        %X = alloca i32         ; <i32*> [#uses=1]
        %Y = alloca i32         ; <i32*> [#uses=1]
        %allocapt = bitcast i32 undef to i32            ; <i32> [#uses=0]
        %tmp = load i32* %X             ; <i32> [#uses=1]
        %tmp1 = add i32 1, %tmp         ; <i32> [#uses=1]
        %tmp2 = load i32* %Y            ; <i32> [#uses=1]
        %tmp3 = add i32 %tmp1, %tmp2            ; <i32> [#uses=1]
        ret i32 %tmp3
                ; No predecessors!
        ret i32 undef
}

llvm-svn: 39555
 2007-06-02 05:24:33 +00:00
Chris Lattner
03df12294b Add initial support for fixed-size local vardecls. This allows us to compile: 
int func() {
  register int X;
  {
    int Y;

into:

define i32 @func() {
entry:
        %X = alloca i32         ; <i32*> [#uses=0]
        %Y = alloca i32         ; <i32*> [#uses=0]
        %allocapt = bitcast i32 undef to i32            ; <i32> [#uses=0]
...

llvm-svn: 39553
 2007-06-02 04:53:11 +00:00
Chris Lattner
84915fa79b Start stubbing out decl codegen. 
llvm-svn: 39550
 2007-06-02 04:16:21 +00:00
Chris Lattner
3f3dbeedd3 implement codegen support for return of void and simple scalars. 
llvm-svn: 39547
 2007-06-02 03:19:07 +00:00
Chris Lattner
db91b16755 stub out codegen of binary plus. We now compile: 
if (11 + 42) {

to:

        %tmp = add i32 11, 42           ; <i32> [#uses=1]
        %tobool = icmp ne i32 %tmp, 0           ; <i1> [#uses=1]
        br i1 %tobool, label %ifthen, label %ifend


but this doesn't handle any of the interesting/hard stuff yet.

llvm-svn: 39545
 2007-06-02 00:16:28 +00:00
Chris Lattner
5269c0377c Add support for codegen'ing paren exprs and if stmts. We can now codegen: 
void test() {
  goto l;

l:
  if (11) {
    j: ;
  }
}

into:

define void @test() {
entry:
        br label %l

l:              ; preds = %entry
        icmp ne i32 11, 0               ; <i1>:0 [#uses=1]
        br i1 %0, label %ifthen, label %ifend

ifthen:         ; preds = %l
        br label %j

j:              ; preds = %ifthen
        br label %ifend

ifend:          ; preds = %j, %l
}

whoa... :)

llvm-svn: 39533
 2007-05-30 21:03:58 +00:00
Chris Lattner
208ae96a8c implement codegen of integer literals. 
llvm-svn: 39530
 2007-05-30 17:57:17 +00:00
Chris Lattner
ac24820fa5 Implement codegen support for labels and gotos. We now compile: 
void test1() {
  foo:
    goto foo;
    goto foo;
    goto foo;
}

void test() {
  goto l;

l:
  ;
}
into:

define void @test1() {
entry:
        br label %foo

foo:            ; preds = %0, %foo, %entry
        br label %foo
                ; No predecessors!
        br label %foo
                ; No predecessors!
}

define void @test() {
entry:
        br label %l

l:              ; preds = %entry
}

llvm-svn: 39524
 2007-05-30 00:13:02 +00:00
Chris Lattner
308f431017 Add codegen support for NullStmt and CompoundStmt. {;;{};;} is now ours! 
llvm-svn: 39522
 2007-05-29 23:50:05 +00:00
Chris Lattner
d1af2d2956 Implement conversion of clang ast types to LLVM types, at least for some trivial 
cases.

llvm-svn: 39519
 2007-05-29 23:17:50 +00:00
Chris Lattner
bed314465a Reorganize codegen files. 
llvm-svn: 39504
 2007-05-28 01:07:47 +00:00