shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity
86,519 Commits 1,713 Branches 298 Tags
Commit Graph

3791 Commits

Author SHA1 Message Date
John McCall
189223e222 Make CGBuilderTy a typedef again; its functionality has been rolled back 
into IRBuilder.

llvm-svn: 107687
 2010-07-06 18:43:48 +00:00
John McCall
2d605ac1f5 When destroying a cleanup, kill any references to instructions in the entry 
block before deleting it.  Fixes PR7575.

This really just a short-term fix before implementing lazy cleanups.

llvm-svn: 107676
 2010-07-06 17:35:03 +00:00
John McCall
466e221037 When creating functions to run global initializers and destructors, mark them 
as nounwind in -fno-exceptions.  Fixes rdar://problem/8090834.

llvm-svn: 107639
 2010-07-06 04:38:10 +00:00
John McCall
bd30929e4d Validated by nightly-test runs on x86 and x86-64 darwin, including after 
self-host.  Hopefully these results hold up on different platforms.  

I tried to keep the GNU ObjC runtime happy, but it's hard for me to test.
Reimplement how clang generates IR for exceptions.  Instead of creating new
invoke destinations which sequentially chain to the previous destination,
push a more semantic representation of *why* we need the cleanup/catch/filter
behavior, then collect that information into a single landing pad upon request.

Also reorganizes how normal cleanups (i.e. cleanups triggered by non-exceptional
control flow) are generated, since it's actually fairly closely tied in with
the former.  Remove the need to track which cleanup scope a block is associated
with.

Document a lot of previously poorly-understood (by me, at least) behavior.

The new framework implements the Horrible Hack (tm), which requires every
landing pad to have a catch-all so that inlining will work.  Clang no longer
requires the Horrible Hack just to make exceptions flow correctly within
a function, however.  The HH is an unfortunate requirement of LLVM's EH IR.

llvm-svn: 107631
 2010-07-06 01:34:17 +00:00
Chris Lattner
ceddafb846 Generate fewer first class aggregate values for other 
coerce cases (e.g. {double,int}) which avoids fastisel
bailing out at -O0.

llvm-svn: 107628
 2010-07-05 20:41:41 +00:00
Chris Lattner
c401de9998 in the "coerce" case, the ABI handling code ends up making the 
alloca for an argument.  Make sure the argument gets the proper
decl alignment, which may be different than the type alignment.

This fixes PR7567

llvm-svn: 107627
 2010-07-05 20:21:00 +00:00
Chris Lattner
53b479ff6a fix PR7564 a cast where the bitfield struct init code 
wasn't handling array padding elements right.

llvm-svn: 107621
 2010-07-05 18:03:30 +00:00
Chris Lattner
9a3459f1a6 AppendBitField really can never fail, so return its return value. 
Everyone knows that no bugs are ever possible with bitfields.

llvm-svn: 107620
 2010-07-05 17:04:23 +00:00
Charles Davis
3babfba597 Mangle Objective-C pointers and block pointers in the Microsoft C++ Mangler. 
ObjC pointers were easy enough (as far as the ABI is concerned, they're
just pointers to structs), but I had to invent a new mangling for block
pointers. This is particularly worrying with the Microsoft ABI, because
it is a vendor-specific ABI; extending it could come back to bite us
later when MS extends it on their own (and you know they will).

llvm-svn: 107572
 2010-07-03 16:56:59 +00:00
John McCall
1180f8e90f Provide convenience routines to save and restore the current insertion 
point.

llvm-svn: 107570
 2010-07-03 09:25:20 +00:00
Charles Davis
3b10dd1bec Fix mangling of array dimensions in the Microsoft C++ Mangler. 
llvm-svn: 107568
 2010-07-03 08:15:16 +00:00
Charles Davis
d49950a317 Mangle member pointer types in the Microsoft C++ Mangler. 
llvm-svn: 107567
 2010-07-03 08:01:32 +00:00
Charles Davis
0029a2a957 Fix mangling of function pointers in the Microsoft C++ Mangler. 
llvm-svn: 107564
 2010-07-03 05:53:41 +00:00
Charles Davis
77552766d9 Fix mangling of array parameters for functions in the Microsoft C++ Mangler. 
Only actual functions get mangled correctly; I don't know how to fix it for
function pointers yet. Thanks to John McCall for the hint.

Also, mangle anonymous tag types. I don't have a suitable testcase yet; I have
a feeling that that's going to need support for static locals, and I haven't
figured out exactly how MSVC's scheme for mangling those works.

llvm-svn: 107561
 2010-07-03 02:41:45 +00:00
Douglas Gregor
bac7490ffc Remove unnecessary ASTContext parameter from 
CXXRecordDecl::getDestructor(); no functionality change.

llvm-svn: 107394
 2010-07-01 14:13:13 +00:00
Chris Lattner
0e7929f30c fix rdar://8147692 - yet another crash due to my abi work. 
llvm-svn: 107387
 2010-07-01 06:20:47 +00:00
Daniel Dunbar
bb7ac52e02 Driver/IRgen: Add support for -momit-leaf-frame-pointer. 
llvm-svn: 107367
 2010-07-01 01:31:45 +00:00
Daniel Dunbar
3de064dfdf Revert "IRgen: Make sure any prolog instructions get debug info.", the lexical 
scope hasn't been set up yet so this isn't valid. It was just a cleanup to the
IR, so I'm going to ignore it for now.

llvm-svn: 107356
 2010-07-01 00:16:31 +00:00
Daniel Dunbar
6696e22cc9 IRgen: Fix debug info regression in r106970; when we eliminate the return value 
store make sure to move the debug metadata from the store (which is actual
'return' statement location) to the return instruction (which otherwise would
have the function end location as its debug info).
 - Tested by gdb test suite.

llvm-svn: 107322
 2010-06-30 21:27:58 +00:00
Daniel Dunbar
d7ac9a375a IRgen: Make sure any prolog instructions get debug info. 
llvm-svn: 107320
 2010-06-30 21:27:56 +00:00
Chris Lattner
5c740f1523 Reapply: 
r107173, "fix PR7519: after thrashing around and remembering how all this stuff"
r107216, "fix PR7523, which was caused by the ABI code calling ConvertType instead"

This includes a fix to make ConvertTypeForMem handle the "recursive" case, and call
it as such when lowering function types which have an indirect result.

llvm-svn: 107310
 2010-06-30 19:14:05 +00:00
Fariborz Jahanian
02995320e9 Use isFunctionOrMethod for vars declared locallly 
in method/blocks to decide not to mangle them.

llvm-svn: 107309
 2010-06-30 18:57:21 +00:00
Fariborz Jahanian
0f19afb9d4 extern variable declared locally to objective-c++ method 
should not be mangled either. Fixes radar 8016412.

llvm-svn: 107303
 2010-06-30 18:27:47 +00:00
Chris Lattner
749b8ed5af reduce nesting. 
llvm-svn: 107292
 2010-06-30 16:58:07 +00:00
Charles Davis
2a47730767 Mangle arrays in the Microsoft C++ Mangler. It's not quite finished (it 
doesn't mangle array parameters right), but I think that should be fixed
in Sema (Doug, John, what do you think?).

Also, stub out the remaining mangleType() routines.

llvm-svn: 107264
 2010-06-30 08:09:57 +00:00
Daniel Dunbar
e422266926 Revert r107173, "fix PR7519: after thrashing around and remembering how all this stuff", it broke bootstrap. 
llvm-svn: 107232
 2010-06-30 00:22:35 +00:00
Daniel Dunbar
8386469d7d Revert r107216, "fix PR7523, which was caused by the ABI code calling ConvertType instead", it is part of a boostrap breaking sequence. 
llvm-svn: 107231
 2010-06-30 00:22:30 +00:00
Daniel Dunbar
8c94ffe776 IRgen: Assignment to Objective-C properties shouldn't reload the value, for 
complex values either. Previously we did this properly for regular assignment,
but not for compound assignment.
 - Also, tidy up assignment code a bit to look more like the scalar path.

llvm-svn: 107217
 2010-06-29 22:44:21 +00:00
Chris Lattner
466b1419c6 fix PR7523, which was caused by the ABI code calling ConvertType instead 
of ConvertTypeRecursive when it needed to in a few cases, causing pointer
types to get resolved at the wrong time.

llvm-svn: 107216
 2010-06-29 22:39:04 +00:00
Daniel Dunbar
c85ea8e175 IRgen: Assignment to Objective-C properties shouldn't reload the value (which 
would trigger an extra method call).
 - While in the area, I also changed Clang to not emit an unnecessary load from
   'x' in cases like 'y = (x = 1)'.

llvm-svn: 107210
 2010-06-29 22:00:45 +00:00
Chris Lattner
cccaad9584 change ABIArgInfo to hold its llvm type with PATypeHolder so that 
it doesn't dangle as types get refined.  This fixes Shootout-C++/lists1
and probably also PR7522.

llvm-svn: 107196
 2010-06-29 19:21:36 +00:00
Chris Lattner
34d6281ae5 relax the CGFunctionInfo::CGFunctionInfo ctor to allow any sequence 
of CanQualTypes to be passed in.

llvm-svn: 107176
 2010-06-29 18:13:52 +00:00
Chris Lattner
ab1e65e2ea fix PR7519: after thrashing around and remembering how all this stuff 
works, the fix is quite simple: just make sure to call ConvertTypeRecursive
when the function type being lowered is in the midst of ConvertType.

llvm-svn: 107173
 2010-06-29 17:56:33 +00:00
Chris Lattner
e70a007b36 minor cleanups. 
llvm-svn: 107150
 2010-06-29 16:40:28 +00:00
Chris Lattner
22a931e3bb Change X86_64ABIInfo to have ASTContext and TargetData ivars to 
avoid passing ASTContext down through all the methods it has.

When classifying an argument, or argument piece, as INTEGER, check
to see if we have a pointer at exactly the same offset in the 
preferred type.  If so, use that pointer type instead of i64.  This
allows us to compile A function taking a stringref into something
like this:

define i8* @foo(i64 %D.coerce0, i8* %D.coerce1) nounwind ssp {
entry:
  %D = alloca %struct.DeclGroup, align 8          ; <%struct.DeclGroup*> [#uses=4]
  %0 = getelementptr %struct.DeclGroup* %D, i32 0, i32 0 ; <i64*> [#uses=1]
  store i64 %D.coerce0, i64* %0
  %1 = getelementptr %struct.DeclGroup* %D, i32 0, i32 1 ; <i8**> [#uses=1]
  store i8* %D.coerce1, i8** %1
  %tmp = getelementptr inbounds %struct.DeclGroup* %D, i32 0, i32 0 ; <i64*> [#uses=1]
  %tmp1 = load i64* %tmp                          ; <i64> [#uses=1]
  %tmp2 = getelementptr inbounds %struct.DeclGroup* %D, i32 0, i32 1 ; <i8**> [#uses=1]
  %tmp3 = load i8** %tmp2                         ; <i8*> [#uses=1]
  %add.ptr = getelementptr inbounds i8* %tmp3, i64 %tmp1 ; <i8*> [#uses=1]
  ret i8* %add.ptr
}

instead of this:

define i8* @foo(i64 %D.coerce0, i64 %D.coerce1) nounwind ssp {
entry:
  %D = alloca %struct.DeclGroup, align 8          ; <%struct.DeclGroup*> [#uses=3]
  %0 = insertvalue %0 undef, i64 %D.coerce0, 0    ; <%0> [#uses=1]
  %1 = insertvalue %0 %0, i64 %D.coerce1, 1       ; <%0> [#uses=1]
  %2 = bitcast %struct.DeclGroup* %D to %0*       ; <%0*> [#uses=1]
  store %0 %1, %0* %2, align 1
  %tmp = getelementptr inbounds %struct.DeclGroup* %D, i32 0, i32 0 ; <i64*> [#uses=1]
  %tmp1 = load i64* %tmp                          ; <i64> [#uses=1]
  %tmp2 = getelementptr inbounds %struct.DeclGroup* %D, i32 0, i32 1 ; <i8**> [#uses=1]
  %tmp3 = load i8** %tmp2                         ; <i8*> [#uses=1]
  %add.ptr = getelementptr inbounds i8* %tmp3, i64 %tmp1 ; <i8*> [#uses=1]
  ret i8* %add.ptr
}

This implements rdar://7375902 - [codegen quality] clang x86-64 ABI lowering code punishing StringRef

llvm-svn: 107123
 2010-06-29 06:01:59 +00:00
Chris Lattner
399d22ac1b plumb preferred types down into X86_64ABIInfo::classifyArgumentType, 
no functionality change.

llvm-svn: 107115
 2010-06-29 01:14:09 +00:00
Chris Lattner
1d7c9f7f4b Pass the LLVM IR version of argument types down into computeInfo. 
This is somewhat annoying to do this at this level, but it avoids
having ABIInfo know depend on CodeGenTypes for a hint.

Nothing is using this yet, so no functionality change.

llvm-svn: 107111
 2010-06-29 01:08:48 +00:00
Chris Lattner
9e748e9d6e add IR names to coerced arguments. 
llvm-svn: 107105
 2010-06-29 00:14:52 +00:00
Chris Lattner
15ec361bd6 make the argument passing stuff in the FCA case smarter still, by 
avoiding making the FCA at all when the types exactly line up.  For
example, before we made:

%struct.DeclGroup = type { i64, i64 }

define i64 @_Z3foo9DeclGroup(i64, i64) nounwind {
entry:
  %D = alloca %struct.DeclGroup, align 8          ; <%struct.DeclGroup*> [#uses=3]
  %2 = insertvalue %struct.DeclGroup undef, i64 %0, 0 ; <%struct.DeclGroup> [#uses=1]
  %3 = insertvalue %struct.DeclGroup %2, i64 %1, 1 ; <%struct.DeclGroup> [#uses=1]
  store %struct.DeclGroup %3, %struct.DeclGroup* %D
  %tmp = getelementptr inbounds %struct.DeclGroup* %D, i32 0, i32 0 ; <i64*> [#uses=1]
  %tmp1 = load i64* %tmp                          ; <i64> [#uses=1]
  %tmp2 = getelementptr inbounds %struct.DeclGroup* %D, i32 0, i32 1 ; <i64*> [#uses=1]
  %tmp3 = load i64* %tmp2                         ; <i64> [#uses=1]
  %add = add nsw i64 %tmp1, %tmp3                 ; <i64> [#uses=1]
  ret i64 %add
}

... which has the pointless insertvalue, which fastisel hates, now we
make:

%struct.DeclGroup = type { i64, i64 }

define i64 @_Z3foo9DeclGroup(i64, i64) nounwind {
entry:
  %D = alloca %struct.DeclGroup, align 8          ; <%struct.DeclGroup*> [#uses=4]
  %2 = getelementptr %struct.DeclGroup* %D, i32 0, i32 0 ; <i64*> [#uses=1]
  store i64 %0, i64* %2
  %3 = getelementptr %struct.DeclGroup* %D, i32 0, i32 1 ; <i64*> [#uses=1]
  store i64 %1, i64* %3
  %tmp = getelementptr inbounds %struct.DeclGroup* %D, i32 0, i32 0 ; <i64*> [#uses=1]
  %tmp1 = load i64* %tmp                          ; <i64> [#uses=1]
  %tmp2 = getelementptr inbounds %struct.DeclGroup* %D, i32 0, i32 1 ; <i64*> [#uses=1]
  %tmp3 = load i64* %tmp2                         ; <i64> [#uses=1]
  %add = add nsw i64 %tmp1, %tmp3                 ; <i64> [#uses=1]
  ret i64 %add
}

This only kicks in when x86-64 abi lowering decides it likes us.

llvm-svn: 107104
 2010-06-29 00:06:42 +00:00
Chris Lattner
3dd716c3c3 Change CGCall to handle the "coerce" case where the coerce-to type 
is a FCA to pass each of the elements as individual scalars.  This
produces code fast isel is less likely to reject and is easier on
the optimizers.

For example, before we would compile:
struct DeclGroup { long NumDecls; char * Y; };
char * foo(DeclGroup D) {
  return D.NumDecls+D.Y;
}

to:
%struct.DeclGroup = type { i64, i64 }

define i64 @_Z3foo9DeclGroup(%struct.DeclGroup) nounwind {
entry:
  %D = alloca %struct.DeclGroup, align 8          ; <%struct.DeclGroup*> [#uses=3]
  store %struct.DeclGroup %0, %struct.DeclGroup* %D, align 1
  %tmp = getelementptr inbounds %struct.DeclGroup* %D, i32 0, i32 0 ; <i64*> [#uses=1]
  %tmp1 = load i64* %tmp                          ; <i64> [#uses=1]
  %tmp2 = getelementptr inbounds %struct.DeclGroup* %D, i32 0, i32 1 ; <i64*> [#uses=1]
  %tmp3 = load i64* %tmp2                         ; <i64> [#uses=1]
  %add = add nsw i64 %tmp1, %tmp3                 ; <i64> [#uses=1]
  ret i64 %add
}

Now we get:

%0 = type { i64, i64 }
%struct.DeclGroup = type { i64, i8* }

define i8* @_Z3foo9DeclGroup(i64, i64) nounwind {
entry:
  %D = alloca %struct.DeclGroup, align 8          ; <%struct.DeclGroup*> [#uses=3]
  %2 = insertvalue %0 undef, i64 %0, 0            ; <%0> [#uses=1]
  %3 = insertvalue %0 %2, i64 %1, 1               ; <%0> [#uses=1]
  %4 = bitcast %struct.DeclGroup* %D to %0*       ; <%0*> [#uses=1]
  store %0 %3, %0* %4, align 1
  %tmp = getelementptr inbounds %struct.DeclGroup* %D, i32 0, i32 0 ; <i64*> [#uses=1]
  %tmp1 = load i64* %tmp                          ; <i64> [#uses=1]
  %tmp2 = getelementptr inbounds %struct.DeclGroup* %D, i32 0, i32 1 ; <i8**> [#uses=1]
  %tmp3 = load i8** %tmp2                         ; <i8*> [#uses=1]
  %add.ptr = getelementptr inbounds i8* %tmp3, i64 %tmp1 ; <i8*> [#uses=1]
  ret i8* %add.ptr
}

Elimination of the FCA inside the function is still-to-come.

llvm-svn: 107099
 2010-06-28 23:44:11 +00:00
Chris Lattner
d200eda487 make the trivial forms of CreateCoerced{Load|Store} trivial. 
llvm-svn: 107091
 2010-06-28 22:51:39 +00:00
Chris Lattner
93af332819 pass/return structs of char and short as i8/i16 to avoid 
aweful through-memory coersion, just like we do for i32 now.

llvm-svn: 107078
 2010-06-28 21:59:07 +00:00
Chris Lattner
d776fb150e more tidying up. 
llvm-svn: 107076
 2010-06-28 21:43:59 +00:00
Chris Lattner
0cf2419cd7 random acts of tidying. 
llvm-svn: 107050
 2010-06-28 20:05:43 +00:00
Chris Lattner
a7d81ab7f3 X86-64: 
pass/return structs of float/int as float/i32 instead of double/i64
to make the code generated for ABI cleaner.  Passing in the low part
of a double is the same as passing in a float.

For example, we now compile:

struct DeclGroup { float NumDecls; };
float foo(DeclGroup D);
void bar(DeclGroup *D) {
 foo(*D);
}

into:

%struct.DeclGroup = type { float }

define void @_Z3barP9DeclGroup(%struct.DeclGroup* %D) nounwind {
entry:
  %D.addr = alloca %struct.DeclGroup*, align 8    ; <%struct.DeclGroup**> [#uses=2]
  %agg.tmp = alloca %struct.DeclGroup, align 4    ; <%struct.DeclGroup*> [#uses=2]
  store %struct.DeclGroup* %D, %struct.DeclGroup** %D.addr
  %tmp = load %struct.DeclGroup** %D.addr         ; <%struct.DeclGroup*> [#uses=1]
  %tmp1 = bitcast %struct.DeclGroup* %agg.tmp to i8* ; <i8*> [#uses=1]
  %tmp2 = bitcast %struct.DeclGroup* %tmp to i8*  ; <i8*> [#uses=1]
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %tmp1, i8* %tmp2, i64 4, i32 4, i1 false)
  %coerce.dive = getelementptr %struct.DeclGroup* %agg.tmp, i32 0, i32 0 ; <float*> [#uses=1]
  %0 = load float* %coerce.dive, align 1          ; <float> [#uses=1]
  %call = call float @_Z3foo9DeclGroup(float %0)  ; <float> [#uses=0]
  ret void
}

instead of:

%struct.DeclGroup = type { float }

define void @_Z3barP9DeclGroup(%struct.DeclGroup* %D) nounwind {
entry:
  %D.addr = alloca %struct.DeclGroup*, align 8    ; <%struct.DeclGroup**> [#uses=2]
  %agg.tmp = alloca %struct.DeclGroup, align 4    ; <%struct.DeclGroup*> [#uses=2]
  %tmp3 = alloca double                           ; <double*> [#uses=2]
  store %struct.DeclGroup* %D, %struct.DeclGroup** %D.addr
  %tmp = load %struct.DeclGroup** %D.addr         ; <%struct.DeclGroup*> [#uses=1]
  %tmp1 = bitcast %struct.DeclGroup* %agg.tmp to i8* ; <i8*> [#uses=1]
  %tmp2 = bitcast %struct.DeclGroup* %tmp to i8*  ; <i8*> [#uses=1]
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %tmp1, i8* %tmp2, i64 4, i32 4, i1 false)
  %coerce.dive = getelementptr %struct.DeclGroup* %agg.tmp, i32 0, i32 0 ; <float*> [#uses=1]
  %0 = bitcast double* %tmp3 to float*            ; <float*> [#uses=1]
  %1 = load float* %coerce.dive                   ; <float> [#uses=1]
  store float %1, float* %0, align 1
  %2 = load double* %tmp3                         ; <double> [#uses=1]
  %call = call float @_Z3foo9DeclGroup(double %2) ; <float> [#uses=0]
  ret void
}

which is this machine code (at -O0):

__Z3barP9DeclGroup:
	subq	$24, %rsp
	movq	%rdi, 16(%rsp)
	movq	16(%rsp), %rdi
	leaq	8(%rsp), %rax
	movl	(%rdi), %ecx
	movl	%ecx, (%rax)
	movss	8(%rsp), %xmm0
	callq	__Z3foo9DeclGroup
	addq	$24, %rsp
	ret

vs this:

__Z3barP9DeclGroup:
	subq	$24, %rsp
	movq	%rdi, 16(%rsp)
	movq	16(%rsp), %rdi
	leaq	8(%rsp), %rax
	movl	(%rdi), %ecx
	movl	%ecx, (%rax)
	movss	8(%rsp), %xmm0
	movss	%xmm0, (%rsp)
	movsd	(%rsp), %xmm0
	callq	__Z3foo9DeclGroup
	addq	$24, %rsp
	ret

At -O3, it is the difference between this now:

__Z3barP9DeclGroup:
	movss	(%rdi), %xmm0
	jmp	__Z3foo9DeclGroup  # TAILCALL

vs this before:

__Z3barP9DeclGroup:
	movl	(%rdi), %eax
	movd	%rax, %xmm0
	jmp	__Z3foo9DeclGroup  # TAILCALL

llvm-svn: 107048
 2010-06-28 19:56:59 +00:00
Fariborz Jahanian
c42461e145 Minor refactorin of my last patch (radar 7860965 related). 
llvm-svn: 107047
 2010-06-28 19:42:10 +00:00
Fariborz Jahanian
36ad0e99d5 Have __func__ and siblings point to block's implementation function 
name. Fixes radar 7860965.

llvm-svn: 107044
 2010-06-28 18:58:34 +00:00
Chris Lattner
c1028f689e Fix UnitTests/2004-02-02-NegativeZero.c, which regressed when 
I broke negate of FP values.

llvm-svn: 107019
 2010-06-28 17:12:37 +00:00
Anders Carlsson
3f48c603fb Correctly destroy reference temporaries with global storage. Remove ErrorUnsupported call when binding a global reference to a non-lvalue. Fixes PR7326. 
llvm-svn: 106983
 2010-06-27 17:52:15 +00:00
Anders Carlsson
18c205ecdf Add a CreateReferenceTemporary that will do the right thing for variables with global storage. 
llvm-svn: 106982
 2010-06-27 17:23:46 +00:00