[IR] Reformulate LLVM's EH funclet IR

[majnemer]

Summary

While we have successfully implemented a funclet-oriented EH scheme on
top of LLVM IR, our scheme has some notable deficiencies:

• catchendpad and cleanupendpad are necessary in the current design but they are difficult to explain to others, even to seasoned LLVM experts.
• catchendpad and cleanupendpad are optimization barriers. They cannot be split and force all potentially throwing call-sites to be invokes. This has a noticable effect on the quality of our code generation.
• catchpad, while similar in some aspects to invoke, is fairly awkward. It is unsplittable, starts a funclet, and has control flow to other funclets.
• The nesting relationship between funclets is currently a property of control flow edges. Because of this, we are forced to carefully analyze the flow graph to see if there might potentially exist illegal nesting among funclets. While we have logic to clone funclets when they are illegally nested, it would be nicer if we had a representation which forbade them upfront.

Let's clean this up a bit by doing the following:

• Instead, make catchpad more like cleanuppad and landingpad: no control flow, just a bunch of simple operands; catchpad would be splittable.
• Introduce catchswitch, a control flow instruction designed to model the constraints of funclet oriented EH.
• Make funclet scoping explicit by having funclet instructions consume the token produced by the funclet which contains them.
• Remove catchendpad and cleanupendpad. Their presence can be inferred implicitly using coloring information.

N.B. The state numbering code for the CLR has been updated but the
veracity of it's output cannot be spoken for. An expert should take a
look to make sure the results are reasonable.

[andrew.w.kaylor]

include/llvm/IR/Instructions.h

3861 ↗

(On Diff #41591)

Should you also assert(UnwindCase)?

3889 ↗

(On Diff #41591)

The word 'handler' seems to be missing here and below.

4142 ↗

(On Diff #41591)

Is OuterScope here really the outer scope or is it the CatchSwitch statement?

This feels like a glitch in the inheritance hierarchy. This argument has different significance for CleanupPadInst than it does here, right?

[majnemer]

• Move colorEHFunclets to EHPersonalities.h
• Fix some first draft review comments

docs/ExceptionHandling.rst

697 ↗

(On Diff #41591)

This change seems reasonable, I'll give it a shot.

712 ↗

(On Diff #41591)

I'll add an example which uses funclet parent tokens.

717–719 ↗

(On Diff #41591)

Done.

723–726 ↗

(On Diff #41591)

The token consumed by the catchpad prohibits simplifycfg from merging together two catchpads belonging to different catchswitches. While we could make this an IR invariant, we get it for free by encoding it in the instruction.

724 ↗

(On Diff #41591)

Done.

docs/LangRef.rst

5328 ↗

(On Diff #41591)

Done.

5334 ↗

(On Diff #41591)

Done.

5334 ↗

(On Diff #41591)

Done.

5342 ↗

(On Diff #41591)

I believe that the CatchSwitchInst in-memory representation and the textual representation should have a 1-1 correspondence with the in-memory representation. However, I like the idea of catchswitch within none ....

5345–5346 ↗

(On Diff #41591)

Done.

5348 ↗

(On Diff #41591)

Done.

5355 ↗

(On Diff #41591)

Done.

5389 ↗

(On Diff #41591)

Done.

5402 ↗

(On Diff #41591)

Done.

5518–5528 ↗

(On Diff #41591)

Done.

8627–8632 ↗

(On Diff #41591)

Done.

include/llvm/Bitcode/LLVMBitCodes.h

425 ↗

(On Diff #41591)

That would gratuitously break bitcode compatibility.

include/llvm/IR/InstrTypes.h

1140 ↗

(On Diff #41591)

Done.

1151 ↗

(On Diff #41591)

Done.

include/llvm/IR/Instructions.h

3848 ↗

(On Diff #41591)

Done.

3947 ↗

(On Diff #41591)

Done.

4086 ↗

(On Diff #41591)

It makes it easier to keep the code in sync with the public constructors which need the same computation to allocate the memory for the use list.

4114 ↗

(On Diff #41591)

Done.

4131 ↗

(On Diff #41591)

Same reason as catchpad.

4191 ↗

(On Diff #41591)

The operator constraints were a victim working through various iterations of EH cleanups. They didn't end up catching any bugs that the verifier couldn't catch. Even so, the getters are all strongly-typed.

lib/Analysis/CFG.cpp

241 ↗

(On Diff #41591)

Done in rL254562

lib/CodeGen/WinEHPrepare.cpp

86 ↗

(On Diff #41591)

Nothing changed per-se, I believe we were just getting lucky. The problematic case is iterating over FuncletBlocks in cloneCommonBlocks. We clone each block and insert it after the original. Using a map doesn't ensure any particular order, resulting in the possibility of different output if we cloned a block multiple times for a funclet.

321 ↗

(On Diff #41591)

Done.

416–417 ↗

(On Diff #41591)

Please feel free :)

lib/IR/Instructions.cpp

994–995 ↗

(On Diff #41591)

Done.

1002 ↗

(On Diff #41591)

I'm not sure I understand what's wrong with inOutermostScope.

lib/IR/Verifier.cpp

2907 ↗

(On Diff #41591)

Done.

2910 ↗

(On Diff #41591)

Done.

2916 ↗

(On Diff #41591)

Done.

2919 ↗

(On Diff #41591)

Done, added in visitEHPadPredecessors.

lib/Transforms/Utils/InlineFunction.cpp

183–203 ↗

(On Diff #41591)

Done.

261–264 ↗

(On Diff #41591)

Done.

338 ↗

(On Diff #41591)

Done.

361–362 ↗

(On Diff #41591)

Done.

1110–1115 ↗

(On Diff #41591)

Done.

lib/Transforms/Utils/SimplifyCFG.cpp

3282–3283 ↗

(On Diff #41591)

Added a comment stating this.

3503–3506 ↗

(On Diff #41591)

Added a comment stating this.

test/CodeGen/WinEH/wineh-cloning.ll

551–553 ↗

(On Diff #41591)

Done.

test/CodeGen/X86/win32-seh-cleanupendpad.ll

1 ↗

(On Diff #41591)

Done.

[majnemer]

include/llvm/IR/Instructions.h

3861 ↗

(On Diff #41703)

Done.

3889 ↗

(On Diff #41703)

Done.

4163 ↗

(On Diff #41703)

The way I saw it, the outer scope of a catchpad is it's catchswitch.

[majnemer]

• Address Andy's latest comments
• Make the IR a little easier to read

[majnemer]

lib/CodeGen/WinEHPrepare.cpp

1858–1860 ↗

(On Diff #41715)

Thinking this over, it is not enough for the catchpad to be deleted even if it is immediately followed by unreachable. For the C++ personality, the catchpad denotes program code executed by the personality routine (copy constructors for catch parameters). While grotesque, it is conceivable that the copy-constructor never returns and continues to call other functions, etc.

AFAICT, it is OK if the catch-parameter's type will not result in copy-constructors getting executed.

[JosephTremoulet]

docs/ExceptionHandling.rst

757–760 ↗

(On Diff #41715)

Bother. I rather liked the idea that "handler", "funclet", and "pad that produces a token" were all interchangeable (modulo a little trickery around SEH catches, but my mental model for that is that EH prep moves the code out of the pad/handler/funclet and then the empty funclet doesn't have any code generated for it). Having catchswitch produce a token means that the "pad tree" has extra nodes as compared to the "funclet tree". But yeah, maybe that's the right way to go.

docs/LangRef.rst

5342 ↗

(On Diff #41715)

I can see the merit to keeping that 1-1 correspondence, but honestly then I'd rather achieve that by omitting the None token from both representations for top-level pads, so that we don't have to think about it in the common case that we're looking at or building a top-level pad, and so that someone trying to grok the IR concepts doesn't need to puzzle over it before understanding the nested cases, at the cost of a bit of complexity in the constructors that we'll mostly never look at again and also the cost of having top-level <-> nested rewrites be a replacement rather than a mutation. I don't feel strongly enough to insist, though.

8618–8631 ↗

(On Diff #41715)

1 - I don't think the " Catchpad should say something similar, and cleanupret and catchret should either refer to this or describe themselves that it's UB to exit the pad that's not the current top of the handler stack" part is done.

2 - We also need to explain that all of these exits must have the same target. Are you still intending to tag invokes in funclets with bundles? If so, this agreement can be a verifier rule. If not, it's a verifier rule that the cleanuprets have to match, will have to be UB if an invoke doesn't match the cleanupret (and I don't know what we do if there is no cleanupret but there are invokes that go to different places), and could be either UB or a verifier rule that nested catchswitches/cleanuprets/terminatepads have to match the cleanuprets.

include/llvm/Analysis/CFG.h

92 ↗

(On Diff #41715)

This is the only change in this file now; do you want to revert it?

include/llvm/Bitcode/LLVMBitCodes.h

425 ↗

(On Diff #41715)

Not disagreeing, but trying to understand:

• What's the issue with the gratuitous change?
• Does this have to do with the official compatibility promises around releases, would you be doing this differently depending if 3.7 did/didn't include FUNC_CODE_OPERAND_BUNDLE?
• If we need to avoid breaking bitcode compatibility in this way, do we also need bitcode autoupdate logic that rewrites bitcode using endpads to the new IR?
• Is the idea that 54 will be unused forever, or is it fair game for the next opcode that gets introduced? Does the answer to that change after 3.8 is released?

include/llvm/IR/Instructions.h

4189 ↗

(On Diff #41715)

Sure, the verifier check can in fact catch more bugs and should have been there even with the creation methods strongly-typed -- the benefit of strongly typing the creation methods would be in catching errors statically rather than dynamically and in making the correct pattern a tiny bit more discoverable. That said, I agree it's fine this way.

4220 ↗

(On Diff #41715)

Since the catchswitch is the OuterScope of the catchpad that contains this, I think the naming here is a bit confusing -- what would you think of changing this method to getTargetScope or getDestinationScope or something along those lines?

lib/Analysis/EHPersonalities.cpp

52–57 ↗

(On Diff #41715)

Should this comment or the method name be changed to reflect the fact that a catchswitch gets its own color but isn't a funclet?

lib/CodeGen/WinEHPrepare.cpp

86 ↗

(On Diff #41715)

It wasn't luck. We had non-deterministic output early on, but determinized it in rL246245 by passing around the deterministically-ordered EntryBlocks vector and using it rather than map iteration to drive the outer loop in the cloning code (so that if we cloned a block multiple times we'd do so with a deterministic order of target funclets) and changing the insertion points for the new blocks to be immediately after their originals. Undoing that here seems gratuitous, and IIUC the DenseMap will require a contiguous allocation sized like the number of BasicBlocks, which, while it's not a show-stopper and I'm sure this isn't the only place where we do such a thing, does give me pause, especially when an alternative is available that just needs a contiguous allocation sized like the number of funclets.

1858–1860 ↗

(On Diff #41715)

1 - I think you're replying to another review comment here? This one is about dealing with invokes etc. that target something other than their enclosing funclet's unwind destination, but you seem to be discussing the comment about SimplifyCFGOpt::SimplifyUnreachable

2 - regarding SimplifyUnreachable:
A - Yeesh. Are those really not elidable copies? I'd still like to eventually do this, at least for the CoreCLR personality.
B - I realized after making the original comment that it really should be two discrete steps -- a catchpad whose first instruction is unreachable can (at least for CoreCLR) be removed, and, separately, a catchswitch with no catchpads can be clipped out

lib/IR/Instructions.cpp

1002 ↗

(On Diff #41715)

There are subtly different types of nesting at play:
1 - Whether a thing is nested inside a funclet
2 - Whether a thing is nested inside a handler
3 - Whether a thing is nested inside an EH pad
4 - Whether a thing is nested inside a try region

ISTM that you're using the term Scope to mean #3 in getOuterScope(), but you're using the same term Scope to mean the union of #3 and #4 in inOutermostScope(). So,
1 - Maybe this is just a naming issue, and getOuterScope() should be getOuterPad() or getParentPad() or getEnclosingPad()?
2 - I'd argue that we've strenuously avoided referencing try blocks as regions/scopes/containers in the IR model, so doing so here seems incongruous.
3 - Even assuming for the sake of argument that we want IR to talk about try scopes, it seems odd that the only way in which it does so is to ask if a handler is for a toplevel try in the root function:
3a - Why wouldn't we want to know whether a handler is for a toplevel try in its enclosing funclet?
3b - Why wouldn't we want a way to get from a handler to the handler for the next-outer try? Actually, we have that, but for cleanups we call it getCleanupRetUnwindDest(), for catchswitch/terminatepad we call it getUnwindDest(), and for catchpads we call it getCatchswitch()->getUnwindDest(). Since all of those use the "unwind destination" terminology, switching to "scope" here is, IMO, confusing.

IOW, I think calling this concept "outermost scope" conflates terminology, and that code needing this predicate would be more readable if callers just explicitly checked the conjunction (OuterScope/EnclosingPad == None && UnwindsToCaller/UnwindDest == nullptr).

lib/IR/Verifier.cpp

2850 ↗

(On Diff #41715)

s/it's/its/

lib/Transforms/Utils/InlineFunction.cpp

1109 ↗

(On Diff #41715)

This can be assert(NumColors == 1) now, can't it? We should have colored all reachable code, do we ever try to inline an unreachable callsite?

1433 ↗

(On Diff #41715)

s/it's/its/

[majnemer]

• Make the catchswitch syntax more like invoke

[andrew.w.kaylor]

docs/ExceptionHandling.rst

761 ↗

(On Diff #41780)

This is out of sync with your latest update, right?

docs/LangRef.rst

5368 ↗

(On Diff #41780)

The syntax is stale here.

5430 ↗

(On Diff #41780)

Stale syntax

include/llvm/IR/Instructions.h

4164 ↗

(On Diff #41715)

I suppose that makes some sense. It would be nice to have a comment somewhere in the class definition explaining that.

lib/Analysis/CFG.cpp

21 ↗

(On Diff #41715)

Can these includes go away now?

[rnk]

lib/CodeGen/AsmPrinter/WinException.cpp

415–419 ↗

(On Diff #41780)

The way this is supposed to work is that we're not supposed to emit separate start/end labels for an invoke that happens to be in BaseState. This would occur in this kind of situation:

void f() {
  HasDtor o;
  try {
    g(1);
  } catch(...) {
    g(2); // Also in BaseState
  }
}

In this case, we don't need separate start/end labels for the g(2) call, we can just use the funclet start entry in BaseState. We can treat it just like a potentially throwing call.

443–447 ↗

(On Diff #41780)

Yeah, we should be able to do that.

469–473 ↗

(On Diff #41780)

I don't think I understand the question.

I think the idea is, when we get to the end of the funclet, if there was some previous state change out of the base state, we should emit label entries to transition back to the base state for the epilogue.

lib/CodeGen/WinEHPrepare.cpp

180–184 ↗

(On Diff #41780)

I would expect the CLR to have the same kinds of constraints as C++ here.

The base state is the state of the funclet prologues and epilogues, and it is the state that we previously assigned to the endpads. If there is a plain callsite at the beginning of a funclet before any new exceptional scopes are created, it should be in the base state. If that callsite throws, the runtime should take the appropriate "next action", which would follow the catchswitch unwind edge or the cleanupret unwind edge.

Now that we don't have endpads, we need to identify callsites that unwind out of the funclet. We do this by comparing the unwind destination of the funclet with the unwind destination of each call site, and if they agree, they must be in the base state.

If we don't do this, we would end up in a situation where a call inside a catch funclet gets a state outside of the CatchLow/CatchHigh interval. I'm pretty sure this would confuse CxxFrameHandler3.

[andrew.w.kaylor]

docs/LangRef.rst

8579 ↗

(On Diff #41780)

This syntax is out-of-date.

lib/Analysis/EHPersonalities.cpp

12 ↗

(On Diff #41780)

Is this still needed?

54 ↗

(On Diff #41780)

Are there circumstances where the colors don't include the root funclet?

lib/Analysis/ScalarEvolutionExpander.cpp

102 ↗

(On Diff #41780)

This will crash if the terminatepad unwinds to caller.

lib/AsmParser/LLParser.cpp

2371 ↗

(On Diff #41780)

This comment should have been deleted.

5189 ↗

(On Diff #41780)

Just out of curiosity, is there a reason we can't allow "to label %<unwind>"? It's an easy error to make when hand-editing IR.

5206 ↗

(On Diff #41780)

/// := catchpad within <catchswitch> [<args>*]

[majnemer]

• Move colorEHFunclets to EHPersonalities.h
• Fix some first draft review comments
• Address Andy's latest comments
• Make the IR a little easier to read
• Make the catchswitch syntax more like invoke
• Address Andy's latest comments.
• Address Joseph's review comments
• Remove unneeded #includes

[rnk]

lib/Analysis/EHPersonalities.cpp

54 ↗

(On Diff #41832)

I think the comment means that the list of colors may include the entry block, which isn't strictly speaking a funclet.

lib/AsmParser/LLParser.cpp

5189–5190 ↗

(On Diff #41832)

I like staying consistent with invoke, which does "unwind label %foo".

[JosephTremoulet]

lib/Analysis/EHPersonalities.cpp

54 ↗

(On Diff #41832)

Right, I'm pretty sure I wrote the comment, and that's what I meant -- that the colors *for any given block* may or may not include the root.

lib/CodeGen/AsmPrinter/WinException.cpp

415–419 ↗

(On Diff #41780)

Ok, I think I get it now. The comment here isn't quite right, though -- should probably be something like

Indicate a change of state to the base state.  The caller won't expect start/end
EH labels for this transition, which is handy since we won't have them available
in the case that BaseState == NullState and this is a call rather than an invoke.

469–473 ↗

(On Diff #41780)

Makes sense now, thanks.

799–804 ↗

(On Diff #41832)

Looks like clang-format mangled this comment's line wrapping

lib/CodeGen/WinEHPrepare.cpp

180–184 ↗

(On Diff #41780)

Thanks for the explanation. CoreCLR wants what it calls "duplicate clauses" reported for funclets that correspond to handlers which were themselves in try blocks, so we actually do want to report a state range with the outer state number for a call at the top-level of such a funclet, so for CoreCLR BaseState is always NullState to force that reporting, and I hadn't been thinking of them as distinct concepts.

[andrew.w.kaylor]

lib/Analysis/EHPersonalities.cpp

54 ↗

(On Diff #41832)

Oh, I see. For some reason I read it as saying that the complete set of funclets for the function could "possibly" include the entry block, and it confused me because that will always be a color. I see now that it is actually saying that the set of colors for any given block may (or may not) include the entry block. That makes a lot more sense.

As a minor nit, the commas in this sentence shouldn't be there. I'm going to blame my reading comprehension failure on that.

At the risk of sounding pedantic, it is a little ambiguous as to whether 'F' refers to the set of funclets that are colors for B or a single funclet in that set. From context it has to be a single funclet, but grammatically I think it's the set. I suggest this:

"For any block B the 'colors' of B are the set of funclets (possibly including a root 'funclet' representing the main function) such that each funclet F in that set will need to directly contain B or a copy of B...."

[andrew.w.kaylor]

lib/AsmParser/LLParser.cpp

5189–5190 ↗

(On Diff #41832)

I'm happy with "unwind label %foo" as the preferred and documented syntax. I was only suggesting that the parser tolerate the presence of a 'to' token here. I suppose that's too imprecise for the philosophy of the IR. I can live with that. The number of people who would ever care is likely to be less than five and may only be one.

[rnk]

lib/CodeGen/WinEHPrepare.cpp

180–184 ↗

(On Diff #41832)

It sounds like it's OK if C++ and the CLR number these slightly differently:

void f() {
  try {
    g(0); // state 0
    try {
      g(1); // state 1
    } catch( ...) {
      // C++ needs to be in TryHigh+1 to CatchHigh interval
      g(2); // CLR state 0, C++ state 2
    }
  } catch(...) {
  }
}

You actually want to assign the outer state of 0 to the g(2) call site, and the table emitter will do the work of emitting duplicate clauses on the handler.

In that case, I think you can avoid filling in FuncletBaseStateMap, always use BaseState = NullState, and things will work.

[JosephTremoulet]

lib/CodeGen/WinEHPrepare.cpp

86 ↗

(On Diff #41832)

IIUC the DenseMap will require a contiguous allocation sized like the number of BasicBlocks

Um, sorry, clearly I didn't understand correctly. For one, I meant the MapVector, not the DenseMap, and for two, its vector would be sized like the number of funclets, not the number of blocks. So that's no different footprint-wise than the explicit EntryBlocks vector, and to boot is easier to read and maintain. So, disregard this comment, sorry for the noise.

(and, separately, IIUC now, the DenseMap does indeed fit all its entries in a contiguous allocation, but I'm less concerned with that since the API surface is the same and we can always switch it back to std::map if it makes something blow up [or have DenseMap degrade gracefully or etc])

[andrew.w.kaylor]

lib/CodeGen/WinEHPrepare.cpp

169 ↗

(On Diff #41832)

Am I right in thinking that you could assert(FuncletPad || FuncletEntryBB == &Fn->getEntryBlock()) here?

215 ↗

(On Diff #41832)

This code could really use some comments. I had to build it and step through some examples in the debugger to understand how it works. It would be nice to have a single large comment block somewhere explaining the whole process of state numbering for a C++ function in addition to a few remarks sprinkled throughout this function.

219 ↗

(On Diff #41832)

s/no/not

243 ↗

(On Diff #41832)

This assigns the same base state to all catchpads within a catchswitch. That seems sketchy to me. Consider the following example:

void foo() {
  try {
    f(1);
  } catch (int) {
    f(2);
    try {
      f(3);
    } catch (...) { }
  } catch (...) {
    f(4);
    try {
      f(5);
    } catch (...) {}
  }
}

Because both outer-level catches get the same base state (1), this state will be assigned to both f(2) and f(4). I think it's possible that __CxxFrameHandler3 will correctly deal with the same state appearing in two different funclets, but I'm not confident of that.

261 ↗

(On Diff #41832)

With the new implementation, I don't think it is possible to get here twice for the same cleanup pad. So this could be made an assertion, right?

lib/IR/Verifier.cpp

3011 ↗

(On Diff #41832)

Shouldn't this be verifying the unwind destination?

3022 ↗

(On Diff #41832)

This should also exclude CatchPadInst.

3048 ↗

(On Diff #41832)

This should also exclude CatchPadInst.

[andrew.w.kaylor]

lib/Transforms/Utils/InlineFunction.cpp

371 ↗

(On Diff #41832)

This needs an RAUW for the catchswitch case.

[andrew.w.kaylor]

lib/Transforms/Utils/SimplifyCFG.cpp

3276 ↗

(On Diff #41832)

Can a cleanupret ever unwind to a catchpad? If not, this should be CleanupPadInst.

3284 ↗

(On Diff #41832)

Can you explain to me the scenario where we can't remove the empty cleanup pad?

I would have expected that for any legal IR there would be something we could do to remove the cleanup pad.

test/CodeGen/WinEH/wineh-cloning.ll

276 ↗

(On Diff #41832)

Here, on the other hand, I don't think we need to generalize, since this block won't be cloned.

281 ↗

(On Diff #41832)

Is there any reason to keep this test case? There doesn't seem to be anything interesting happening here.

326 ↗

(On Diff #41832)

This test case also seems to be redundant now.

383 ↗

(On Diff #41832)

It bothers me that this is still apparently legal. I would think that an exception thrown from within a top level EH pad should only be able to unwind to caller. In any event, the test is now verifying that we did not resolve the problem that the old implementation of this test was looking for.

What would the state numbering code do with this if we left it in the state that is checked here?

479 ↗

(On Diff #41832)

This comment is incorrect now, since there is no invoke in %merge anymore. I think this test case is also obsolete.

[JosephTremoulet]

lib/Transforms/Utils/InlineFunction.cpp

1443–1451 ↗

(On Diff #41832)

I think you can remove CallSiteEHPad && from each of these three tests, as it's redundant with the guarding check up on line 1434.

[JosephTremoulet]

lib/Transforms/Utils/InlineFunction.cpp

1099 ↗

(On Diff #41832)

This could be

if (CallerPersonality) {
  assert(CalledPersonality);

since the code just above sets CalledPersonality if it is null but CallerPersonality is not.

[JosephTremoulet]

lib/Transforms/Utils/InlineFunction.cpp

1099 ↗

(On Diff #41832)

...no, I just totally misread that. Sorry for the noise.

[majnemer]

docs/ExceptionHandling.rst

617–618 ↗

(On Diff #41832)

Done.

632–633 ↗

(On Diff #41832)

cleanupret and catchret are similar in that they both exit their constituent funclet. I'll keep it as cleanupret unless there is an overwhelming desire to move in that direction.

761 ↗

(On Diff #41832)

Done.

docs/LangRef.rst

5342 ↗

(On Diff #41715)

I considered this approach while designing the new instructions (i.e. making getOuterScope return nullptr if it has no lexical parent). I rejected it for a few reasons:

• It makes it all too easy to get the nesting wrong if no token is necessary. Things will seem to work until they don't. Making the token always explicit is a way of making IR creators consider the nesting case.
• It provides us a sentinel value which we can use when wanting to talk about scopes. nullptr is often used to indicate failure and I wanted to make sure this confusion would never occur.

Regardless, we can do this change down the road at any time.

8618–8631 ↗

(On Diff #41715)

#1 is done.

With regard to #2, we will tag call-sites in funclets with bundles but this does not allow us to enforce this as a verifier rule. Tail-merging can still make invokes with conflicting/illegal unwind destinations show up in other funclets. The tagging will allow us to get rid of them in WinEHPrepare.

5368 ↗

(On Diff #41832)

Done.

5430 ↗

(On Diff #41832)

Done.

8579 ↗

(On Diff #41832)

Done.

include/llvm/Analysis/CFG.h

92 ↗

(On Diff #41832)

Done.

include/llvm/Bitcode/LLVMBitCodes.h

425 ↗

(On Diff #41832)

Bitcode is supposed to be stable within reason; we are breaking compatibility because it is not sensible to add heroic logic to the auto-upgrader to make these instructions: nobody should have MSVC++ EH bitcodes around.

It is fair game for 54 to be reused because, for all intents and purposes, it has never been used except by a tiny number of people.

Operand bundles are currently under development by other folks, it would be in poor taste to renumber them under their feet.

include/llvm/IR/Instructions.h

4164 ↗

(On Diff #41832)

Done.

4220 ↗

(On Diff #41832)

getTargetScope and getDestinationScope make you feel like they imply the existence of CFG edges which aren't really there. I'll leave this alone unless a compelling name shows up.

lib/Analysis/CFG.cpp

21 ↗

(On Diff #41832)

Done.

lib/Analysis/EHPersonalities.cpp

12 ↗

(On Diff #41832)

Yes, for llvm::successors.

52–57 ↗

(On Diff #41832)

Done.

54 ↗

(On Diff #41832)

Done.

lib/Analysis/ScalarEvolutionExpander.cpp

102–103 ↗

(On Diff #41832)

This code cannot fire if the terminatepad unwinds to caller. It is only possible to get here if we have a PHI on the terminatepad (or one of it's predecessors) and the PHI's use is dominated by the terminatepad. Such a use shouldn't exist if the terminatepad unwinds to caller.

lib/AsmParser/LLParser.cpp

2371–2372 ↗

(On Diff #41832)

Done.

lib/CodeGen/AsmPrinter/WinException.cpp

799–804 ↗

(On Diff #41832)

Done.

lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp

228–234 ↗

(On Diff #41832)

The PHIs in the IR are not the same as the ones we need in the machine CFG. This is because invokes have a single successor in the IR but multiple successors in the machine CFG. To disable the demotion, we would need to fix the PHIs as we build the machine CFG.

lib/CodeGen/WinEHPrepare.cpp

169 ↗

(On Diff #41832)

Done.

219 ↗

(On Diff #41832)

Done.

261 ↗

(On Diff #41832)

It still is because two cleanuprets from the same cleanuppad can unwind to the same funclet-pad. We will then do getEHPadFromPredecessor and visit the same cleanup twice.

lib/IR/Instructions.cpp

936 ↗

(On Diff #41832)

Done.

1002 ↗

(On Diff #41832)

Done.

lib/IR/Verifier.cpp

401–402 ↗

(On Diff #41832)

This is UB, langref is updated.

2850 ↗

(On Diff #41832)

Done.

3011 ↗

(On Diff #41832)

Done.

3022 ↗

(On Diff #41832)

visitEHPadPredecessors should do this for us when we visit CatchPadInst.

3048 ↗

(On Diff #41832)

visitEHPadPredecessors should do this for us when we visit CatchPadInst.

lib/Transforms/Utils/InlineFunction.cpp

371 ↗

(On Diff #41832)

Done.

1433 ↗

(On Diff #41832)

Done.

1443–1451 ↗

(On Diff #41832)

Done.

lib/Transforms/Utils/SimplifyCFG.cpp

3276 ↗

(On Diff #41832)

Done.

test/CodeGen/WinEH/wineh-cloning.ll

276 ↗

(On Diff #41832)

Done.

281 ↗

(On Diff #41832)

Done.

326 ↗

(On Diff #41832)

Done.

383 ↗

(On Diff #41832)

There is no problem here because funclet ancestry is explicit. It should not be necessary for us to do any cloning. It is up to the front-end to emit IR that the personality routine is capable of. However, this example is impossible to construct from the front-end.

479 ↗

(On Diff #41832)

Done.

[majnemer]

• Move colorEHFunclets to EHPersonalities.h
• Fix some first draft review comments
• Address Andy's latest comments
• Make the IR a little easier to read
• Make the catchswitch syntax more like invoke
• Address Andy's latest comments.
• Address Joseph's review comments
• Remove unneeded #includes
• Address Joseph's comments
• Don't unswitch cleanuppads, we don't know how to split invoke edges to them.
• Don't sink into a catchswitch, it won't work.
• Make CatchSwitchInst::handlers() return BasicBlock * intead of const Use &
• Address review comments

[rnk]

lib/CodeGen/WinEHPrepare.cpp

223–231 ↗

(On Diff #42509)

It really could. Comments fell by the wayside because we were impatiently trying to pair program something that would work.

I'm probably the person who should write them, though, so I'd rather commit this and then try to clean up the algorithm in tree.

There's other stuff to do as well. It would be good to share the EH traversal between the CLR, C++, and SEH, so this is probably going to get rewritten.

250 ↗

(On Diff #42509)

This assigns the same base state to all catchpads within a catchswitch. That seems sketchy to me.

That's not actually different from how things work with catchendpad today, and I think it's consistent with what MSVC does. Here's how I read the states produced by MSVC on your example:

void f(int);
void foo() {
  try {
    f(1); // state 0
  } catch (int) {
    f(2); // state 1
    try {
      f(3); // state 2
    } catch (...) {
      // state 3
    }
  } catch (...) {
    f(4); // state 1
    try {
      f(5); // state 4
    } catch (...) {
      // state 5
    }
  }
}
// unwind map
// 0 -> -1
// 1 -> -1
// 2 -> 1
// 3 -> 1
// 4 -> 1
// 5 -> 1

Clang today computes the same table as MSVC on this example, and I'm pretty sure this patch will keep our behavior here the same.

[rnk]

lib/Transforms/Utils/SimplifyCFG.cpp

3284 ↗

(On Diff #42509)

I made this change and I think I completely misunderstood what the code was trying to do. I thought it was trying to merge consecutive cleanups together, not just remove empty cleanups. We can probably revert this.

[JosephTremoulet]

LGTM aside from:

• two naming issues (which, since they're naming issues, are bikeshedding, and could always be changed post-commit anyway):
  • The term "outer scope" used for the "within" argument of pads seems discordant with the rest of our terminology. I'd rather refer to them as "pads" since that's what we call them everywhere else, and just need an adjective. Since the textual IR uses "within", having a good counterpart for that would work, something like getOuterPad or getEnclosingPad or getContainingPad. Since in a few places we'll need to talk about the transitive closure of it, calling it getParentPad would also work for me, so that "ancestor" will be available for the transitive case.
  • I still think it's confusing that a catchret's "outer" scope is the parent of the catchswitch. I tried a few more suggestions inline, of course you'd want to s/Scope/Pad/ in them if the previous bullet sways you.
• one inline nit
• the thing Andy pointed out in SimplifyCFG

include/llvm/IR/Instructions.h

4220 ↗

(On Diff #41832)

I'd argue the edge is there -- you're getting the "scope" that contains the target of the CFG edge. I think getReturnedToScope could make sense, but is awkward. getScopeAtDestination? getOuterScopeOfCatchswitch? getNotExitedAncestorScope? getExitScope? getInvokeScope? getPreExceptionScope? getPreviousScope? getPriorScope?

3907 ↗

(On Diff #42509)

nit: seems like the two handler_helpers should be private.

[rnk]

I like getParentPad best from your list of names for getOuterScope.

[majnemer]

• Address review comments

[JosephTremoulet]

include/llvm/IR/InstrTypes.h

1122 ↗

(On Diff #42556)

(here and other constructors and Create methods) parameter should probably be renamed ParentPad as well.

lib/CodeGen/WinEHPrepare.cpp

207 ↗

(On Diff #42556)

This parameter name too

lib/IR/Verifier.cpp

2994 ↗

(On Diff #42556)

nit: Also these locals (this, visitCatchSwitchInst, and visitTerminatePadInst)

[andrew.w.kaylor]

Except for the irreducible loop issue, this looks good to me. I would be OK with putting off addressing that problem until some later time, as it seems like a fairly unlikely corner case, but I do think we should probably think about it.

lib/CodeGen/WinEHPrepare.cpp

223–232 ↗

(On Diff #42556)

Sounds like a plan.

250 ↗

(On Diff #42556)

OK, if MSVC does this also then I feel a lot better about the long term viability of doing it this way.

test/CodeGen/WinEH/wineh-cloning.ll

288–289 ↗

(On Diff #42556)

The original concern was that some future optimization would innocently transform otherwise reasonable code into this form. I think the hypothetically dangerous input looked something like this:

left:
  cleanuppad within none []
  call void @h(i32 1)
  invoke void @f()
    to label %unreachable unwind label %not_right
not_right:
  cleanuppad within none []
  call void @h(i32 2)
  call void @f()
  unreachable
right:
  cleanuppad within none []
  call void @h(i32 2)
  invoke void @f()
    to label %unreachable unwind label %not_left
not_left:
  cleanuppad within none []
  call void @h(i32 1)
  call void @f()
  unreachable

So if we can get that out of the clang front end, then a reasonable optimization could transform it into this test case, and I don't see how the code generator could do anything reasonable with the form shown in this test case.

[majnemer]

include/llvm/IR/InstrTypes.h

1122 ↗

(On Diff #42556)

Done.

lib/CodeGen/WinEHPrepare.cpp

207 ↗

(On Diff #42556)

Done.

lib/IR/Verifier.cpp

2994 ↗

(On Diff #42556)

Done.

test/CodeGen/WinEH/wineh-cloning.ll

288–289 ↗

(On Diff #42556)

Such a hypothetical optimization would be defeated once we add support for bundle operands in the front-end. The bundle operands will defeat tail-merging/CSE because the call-sites will look like they have different operands.

[JosephTremoulet]

test/CodeGen/WinEH/wineh-cloning.ll

288–289 ↗

(On Diff #42556)

I think this is another example of a case where we'll need the bundles tagging calls/invokes in EH pads. With that, the notion of which pad an invoke "is in" will be well-defined, and we'll be able to add a rule that it's UB to take an invoke's unwind edge if its unwind dest's parent pad isn't the parent of the pad that the invoke is in. WinEHPrep will then be able to prune the UB unwind edges, so if presented with the IR in this test (which, as David points out, couldn't be the result of optimizing your example anymore, but I think would still be legal/verifiable IR) it would see that the two invokes to @f() unwind to illegal destinations, and rewrite those as calls.

[majnemer]

• Move colorEHFunclets to EHPersonalities.h
• Fix some first draft review comments
• Address Andy's latest comments
• Make the IR a little easier to read
• Make the catchswitch syntax more like invoke
• Address Andy's latest comments.
• Address Joseph's review comments
• Remove unneeded #includes
• Address Joseph's comments
• Don't unswitch cleanuppads, we don't know how to split invoke edges to them.
• Don't sink into a catchswitch, it won't work.
• Make CatchSwitchInst::handlers() return BasicBlock * intead of const Use &
• Address review comments
• Address review comments
• Address review comments.

[JosephTremoulet]

LGTM, no caveats.

llvm/trunk/docs/ExceptionHandling.rst

 that have calls only to non-throwing functions. They do not need an exception
 table.
 
 .. _wineh:
 
 Exception Handling using the Windows Runtime
 =================================================
 
-(Note: Windows C++ exception handling support is a work in progress and is not
-yet fully implemented.  The text below describes how it will work when
-completed.)
-
 Background on Windows exceptions
 ---------------------------------
 
-Interacting with exceptions on Windows is significantly more complicated than on
-Itanium C++ ABI platforms. The fundamental difference between the two models is
-that Itanium EH is designed around the idea of "successive unwinding," while
+Interacting with exceptions on Windows is significantly more complicated than
+on Itanium C++ ABI platforms. The fundamental difference between the two models
+is that Itanium EH is designed around the idea of "successive unwinding," while
 Windows EH is not.
 
 Under Itanium, throwing an exception typically involes allocating thread local
 memory to hold the exception, and calling into the EH runtime. The runtime
 identifies frames with appropriate exception handling actions, and successively
 resets the register context of the current thread to the most recently active
 frame with actions to run. In LLVM, execution resumes at a ``landingpad``
 instruction, which produces register values provided by the runtime. If a

 required by the personality, so long as it uses the familiar core EH actions:
 catch, cleanup, and terminate.  However, the new instructions are hard to modify
 without knowing details of the EH personality. While they can be used to
 represent Itanium EH, the landingpad model is strictly better for optimization
 purposes.
 
 The following new instructions are considered "exception handling pads", in that
 they must be the first non-phi instruction of a basic block that may be the
-unwind destination of an invoke: ``catchpad``, ``cleanuppad``, and
-``terminatepad``. As with landingpads, when entering a try scope, if the
+unwind destination of an EH flow edge:
+``catchswitch``, ``catchpad``, ``cleanuppad``, and ``terminatepad``.
+As with landingpads, when entering a try scope, if the
 frontend encounters a call site that may throw an exception, it should emit an
-invoke that unwinds to a ``catchpad`` block. Similarly, inside the scope of a
+invoke that unwinds to a ``catchswitch`` block. Similarly, inside the scope of a
 C++ object with a destructor, invokes should unwind to a ``cleanuppad``. The
 ``terminatepad`` instruction exists to represent ``noexcept`` and throw
 specifications with one combined instruction. All potentially throwing calls in
 a ``noexcept`` function should transitively unwind to a terminateblock. Throw
 specifications are not implemented by MSVC, and are not yet supported.
 
 New instructions are also used to mark the points where control is transferred
 out of a catch/cleanup handler (which will correspond to exits from the
 generated funclet).  A catch handler which reaches its end by normal execution
 executes a ``catchret`` instruction, which is a terminator indicating where in
 the function control is returned to.  A cleanup handler which reaches its end
 by normal execution executes a ``cleanupret`` instruction, which is a terminator
-indicating where the active exception will unwind to next.  A catch or cleanup
-handler which is exited by another exception being raised during its execution will
-unwind through a ``catchendpad`` or ``cleanuupendpad`` (respectively).  The
-``catchendpad`` and ``cleanupendpad`` instructions are considered "exception
-handling pads" in the same sense that ``catchpad``, ``cleanuppad``, and
-``terminatepad`` are.
-
-Each of these new EH pad instructions has a way to identify which
-action should be considered after this action. The ``catchpad`` and
-``terminatepad`` instructions are terminators, and have a label operand considered
-to be an unwind destination analogous to the unwind destination of an invoke. The
-``cleanuppad`` instruction is different from the other two in that it is not a
-terminator. The code inside a cleanuppad runs before transferring control to the
-next action, so the ``cleanupret`` and ``cleanupendpad`` instructions are the
-instructions that hold a label operand and unwind to the next EH pad. All of
-these "unwind edges" may refer to a basic block that contains an EH pad instruction,
-or they may simply unwind to the caller. Unwinding to the caller has roughly the
-same semantics as the ``resume`` instruction in the ``landingpad`` model. When
-inlining through an invoke, instructions that unwind to the caller are hooked
-up to unwind to the unwind destination of the call site.
+indicating where the active exception will unwind to next.
+
+Each of these new EH pad instructions has a way to identify which action should
+be considered after this action. The ``catchswitch`` and ``terminatepad``
+instructions are terminators, and have a unwind destination operand analogous
+to the unwind destination of an invoke.  The ``cleanuppad`` instruction is not
+a terminator, so the unwind destination is stored on the ``cleanupret``
+instruction instead. Successfully executing a catch handler should resume
+normal control flow, so neither ``catchpad`` nor ``catchret`` instructions can
+unwind. All of these "unwind edges" may refer to a basic block that contains an
+EH pad instruction, or they may unwind to the caller.  Unwinding to the caller
+has roughly the same semantics as the ``resume`` instruction in the landingpad
+model. When inlining through an invoke, instructions that unwind to the caller
+are hooked up to unwind to the unwind destination of the call site.
 
 Putting things together, here is a hypothetical lowering of some C++ that uses
 all of the new IR instructions:
 
 .. code-block:: c
 
   struct Cleanup {
     Cleanup();
.. code-block:: llvm
   invoke.cont:                                      ; preds = %entry
     invoke void @"\01?may_throw@@YAXXZ"()
             to label %invoke.cont.2 unwind label %lpad.cleanup
 
   invoke.cont.2:                                    ; preds = %invoke.cont
     call void @"\01??_DCleanup@@QEAA@XZ"(%struct.Cleanup* nonnull %obj) nounwind
     br label %return
 
-  return:                                           ; preds = %invoke.cont.2, %invoke.cont.3
-    %retval.0 = phi i32 [ 0, %invoke.cont.2 ], [ %9, %catch ]
+  return:                                           ; preds = %invoke.cont.3, %invoke.cont.2
+    %retval.0 = phi i32 [ 0, %invoke.cont.2 ], [ %3, %invoke.cont.3 ]
     ret i32 %retval.0
 
-  ; EH scope code, ordered innermost to outermost:
-
-  lpad.cleanup:                                     ; preds = %invoke.cont
-    %cleanup = cleanuppad []
-    call void @"\01??_DCleanup@@QEAA@XZ"(%struct.Cleanup* nonnull %obj) nounwind
-    cleanupret %cleanup unwind label %lpad.catch
+  lpad.cleanup:                                     ; preds = %invoke.cont.2
+    %0 = cleanuppad within none []
+    call void @"\01??1Cleanup@@QEAA@XZ"(%struct.Cleanup* nonnull %obj) nounwind
+    cleanupret %0 unwind label %lpad.catch
 
-  lpad.catch:                                       ; preds = %entry, %lpad.cleanup
-    %catch = catchpad [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i32* %e]
-            to label %catch.body unwind label %catchend
+  lpad.catch:                                       ; preds = %lpad.cleanup, %entry
+    %1 = catchswitch within none [label %catch.body] unwind label %lpad.terminate
 
   catch.body:                                       ; preds = %lpad.catch
+    %catch = catchpad within %1 [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i32* %e]
     invoke void @"\01?may_throw@@YAXXZ"()
-            to label %invoke.cont.3 unwind label %catchend
+            to label %invoke.cont.3 unwind label %lpad.terminate
 
   invoke.cont.3:                                    ; preds = %catch.body
-    %9 = load i32, i32* %e, align 4
-    catchret %catch to label %return
+    %3 = load i32, i32* %e, align 4
+    catchret from %catch to label %return
+
+  lpad.terminate:                                   ; preds = %catch.body, %lpad.catch
+    terminatepad within none [void ()* @"\01?terminate@@YAXXZ"] unwind to caller
+  }
+
+Funclet parent tokens
+-----------------------
+
+In order to produce tables for EH personalities that use funclets, it is
+necessary to recover the nesting that was present in the source. This funclet
+parent relationship is encoded in the IR using tokens produced by the new "pad"
+instructions. The token operand of a "pad" or "ret" instruction indicates which
+funclet it is in, or "none" if it is not nested within another funclet.
+
+The ``catchpad`` and ``cleanuppad`` instructions establish new funclets, and
+their tokens are consumed by other "pad" instructions to establish membership.
+The ``catchswitch`` instruction does not create a funclet, but it produces a
+token that is always consumed by its immediate successor ``catchpad``
+instructions. This ensures that every catch handler modelled by a ``catchpad``
+belongs to exactly one ``catchswitch``, which models the dispatch point after a
+C++ try. The ``terminatepad`` instruction cannot contain lexically nested
+funclets inside the termination action, so it does not produce a token.
 
-  catchend:                                         ; preds = %lpad.catch, %catch.body
-    catchendpad unwind label %lpad.terminate
+Here is an example of what this nesting looks like using some hypothetical
+C++ code:
+
+.. code-block:: c
 
-  lpad.terminate:                                   ; preds = %catchend
-    terminatepad [void ()* @"\01?terminate@@YAXXZ"]
-            unwind to caller
+  void f() {
+    try {
+      throw;
+    } catch (...) {
+      try {
+        throw;
+      } catch (...) {
+      }
     }
+  }
+
+.. code-block:: llvm
+  define void @f() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
+  entry:
+    invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null) #1
+            to label %unreachable unwind label %catch.dispatch
+
+  catch.dispatch:                                   ; preds = %entry
+    %0 = catchswitch within none [label %catch] unwind to caller
+
+  catch:                                            ; preds = %catch.dispatch
+    %1 = catchpad within %0 [i8* null, i32 64, i8* null]
+    invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null) #1
+            to label %unreachable unwind label %catch.dispatch2
+
+  catch.dispatch2:                                  ; preds = %catch
+    %2 = catchswitch within %1 [label %catch3] unwind to caller
+
+  catch3:                                           ; preds = %catch.dispatch2
+    %3 = catchpad within %2 [i8* null, i32 64, i8* null]
+    catchret from %3 to label %try.cont
+
+  try.cont:                                         ; preds = %catch3
+    catchret from %1 to label %try.cont6
+
+  try.cont6:                                        ; preds = %try.cont
+    ret void
+
+  unreachable:                                      ; preds = %catch, %entry
+    unreachable
+  }
+
+The "inner" ``catchswitch`` consumes ``%1`` which is produced by the outer
+catchswitch.

llvm/trunk/docs/LangRef.rst

 block should be executed after the current block is finished. These
 terminator instructions typically yield a '``void``' value: they produce
 control flow, not values (the one exception being the
 ':ref:`invoke <i_invoke>`' instruction).
 
 The terminator instructions are: ':ref:`ret <i_ret>`',
 ':ref:`br <i_br>`', ':ref:`switch <i_switch>`',
 ':ref:`indirectbr <i_indirectbr>`', ':ref:`invoke <i_invoke>`',
-':ref:`resume <i_resume>`', ':ref:`catchpad <i_catchpad>`',
-':ref:`catchendpad <i_catchendpad>`',
+':ref:`resume <i_resume>`', ':ref:`catchswitch <i_catchswitch>`',
 ':ref:`catchret <i_catchret>`',
-':ref:`cleanupendpad <i_cleanupendpad>`',
 ':ref:`cleanupret <i_cleanupret>`',
 ':ref:`terminatepad <i_terminatepad>`',
 and ':ref:`unreachable <i_unreachable>`'.
 
 .. _i_ret:
 
 '``ret``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^

 
 Example:
 """"""""
 
 .. code-block:: llvm
 
       resume { i8*, i32 } %exn
 
-.. _i_catchpad:
+.. _i_catchswitch:
 
-'``catchpad``' Instruction
+'``catchswitch``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      <resultval> = catchpad [<args>*]
-          to label <normal label> unwind label <exception label>
+      <resultval> = catchswitch within <parent> [ label <handler1>, label <handler2>, ... ] unwind to caller
+      <resultval> = catchswitch within <parent> [ label <handler1>, label <handler2>, ... ] unwind label <default>
 
 Overview:
 """""""""
 
-The '``catchpad``' instruction is used by `LLVM's exception handling
-system <ExceptionHandling.html#overview>`_ to specify that a basic block
-is a catch block --- one where a personality routine attempts to transfer
-control to catch an exception.
-The ``args`` correspond to whatever information the personality
-routine requires to know if this is an appropriate place to catch the
-exception. Control is transfered to the ``exception`` label if the
-``catchpad`` is not an appropriate handler for the in-flight exception.
-The ``normal`` label should contain the code found in the ``catch``
-portion of a ``try``/``catch`` sequence. The ``resultval`` has the type
-:ref:`token <t_token>` and is used to match the ``catchpad`` to
-corresponding :ref:`catchrets <i_catchret>`.
+The '``catchswitch``' instruction is used by `LLVM's exception handling system
+<ExceptionHandling.html#overview>`_ to describe the set of possible catch handlers
+that may be executed by the :ref:`EH personality routine <personalityfn>`.
 
 Arguments:
 """"""""""
 
-The instruction takes a list of arbitrary values which are interpreted
-by the :ref:`personality function <personalityfn>`.
+The ``parent`` argument is the token of the funclet that contains the
+``catchswitch`` instruction. If the ``catchswitch`` is not inside a funclet,
+this operand may be the token ``none``.
 
-The ``catchpad`` must be provided a ``normal`` label to transfer control
-to if the ``catchpad`` matches the exception and an ``exception``
-label to transfer control to if it doesn't.
+The ``default`` argument is the label of another basic block beginning with a
+"pad" instruction, one of ``cleanuppad``, ``terminatepad``, or
+``catchswitch``.
+
+The ``handlers`` are a list of successor blocks that each begin with a
+:ref:`catchpad <i_catchpad>` instruction.
 
 Semantics:
 """"""""""
 
-When the call stack is being unwound due to an exception being thrown,
-the exception is compared against the ``args``. If it doesn't match,
-then control is transfered to the ``exception`` basic block.
-As with calling conventions, how the personality function results are
-represented in LLVM IR is target specific.
+Executing this instruction transfers control to one of the successors in
+``handlers``, if appropriate, or continues to unwind via the unwind label if
+present.
 
-The ``catchpad`` instruction has several restrictions:
-
--  A catch block is a basic block which is the unwind destination of
-   an exceptional instruction.
--  A catch block must have a '``catchpad``' instruction as its
-   first non-PHI instruction.
--  A catch block's ``exception`` edge must refer to a catch block or a
-   catch-end block.
--  There can be only one '``catchpad``' instruction within the
-   catch block.
--  A basic block that is not a catch block may not include a
-   '``catchpad``' instruction.
--  A catch block which has another catch block as a predecessor may not have
-   any other predecessors.
--  It is undefined behavior for control to transfer from a ``catchpad`` to a
-   ``ret`` without first executing a ``catchret`` that consumes the
-   ``catchpad`` or unwinding through its ``catchendpad``.
--  It is undefined behavior for control to transfer from a ``catchpad`` to
-   itself without first executing a ``catchret`` that consumes the
-   ``catchpad`` or unwinding through its ``catchendpad``.
+The ``catchswitch`` is both a terminator and a "pad" instruction, meaning that
+it must be both the first non-phi instruction and last instruction in the basic
+block. Therefore, it must be the only non-phi instruction in the block.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
-      ;; A catch block which can catch an integer.
-      %tok = catchpad [i8** @_ZTIi]
-        to label %int.handler unwind label %terminate
+    dispatch1:
+      %cs1 = catchswitch within none [label %handler0, label %handler1] unwind to caller
+    dispatch2:
+      %cs2 = catchswitch within %parenthandler [label %handler0] unwind label %cleanup
 
-.. _i_catchendpad:
+.. _i_catchpad:
 
-'``catchendpad``' Instruction
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+'``catchpad``' Instruction
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      catchendpad unwind label <nextaction>
-      catchendpad unwind to caller
+      <resultval> = catchpad within <catchswitch> [<args>*]
 
 Overview:
 """""""""
 
-The '``catchendpad``' instruction is used by `LLVM's exception handling
-system <ExceptionHandling.html#overview>`_ to communicate to the
-:ref:`personality function <personalityfn>` which invokes are associated
-with a chain of :ref:`catchpad <i_catchpad>` instructions; propagating an
-exception out of a catch handler is represented by unwinding through its
-``catchendpad``.  Unwinding to the outer scope when a chain of catch handlers
-do not handle an exception is also represented by unwinding through their
-``catchendpad``.
-
-The ``nextaction`` label indicates where control should transfer to if
-none of the ``catchpad`` instructions are suitable for catching the
-in-flight exception.
-
-If a ``nextaction`` label is not present, the instruction unwinds out of
-its parent function. The
-:ref:`personality function <personalityfn>` will continue processing
-exception handling actions in the caller.
+The '``catchpad``' instruction is used by `LLVM's exception handling
+system <ExceptionHandling.html#overview>`_ to specify that a basic block
+begins a catch handler --- one where a personality routine attempts to transfer
+control to catch an exception.
 
 Arguments:
 """"""""""
 
-The instruction optionally takes a label, ``nextaction``, indicating
-where control should transfer to if none of the preceding
-``catchpad`` instructions are suitable for the in-flight exception.
+The ``catchswitch`` operand must always be a token produced by a
+:ref:`catchswitch <i_catchswitch>` instruction in a predecessor block. This
+ensures that each ``catchpad`` has exactly one predecessor block, and it always
+terminates in a ``catchswitch``.
+
+The ``args`` correspond to whatever information the personality routine
+requires to know if this is an appropriate handler for the exception. Control
+will transfer to the ``catchpad`` if this is the first appropriate handler for
+the exception.
+
+The ``resultval`` has the type :ref:`token <t_token>` and is used to match the
+``catchpad`` to corresponding :ref:`catchrets <i_catchret>` and other nested EH
+pads.
 
 Semantics:
 """"""""""
 
-When the call stack is being unwound due to an exception being thrown
-and none of the constituent ``catchpad`` instructions match, then
-control is transfered to ``nextaction`` if it is present. If it is not
-present, control is transfered to the caller.
+When the call stack is being unwound due to an exception being thrown, the
+exception is compared against the ``args``. If it doesn't match, control will
+not reach the ``catchpad`` instruction.  The representation of ``args`` is
+entirely target and personality function-specific.
 
-The ``catchendpad`` instruction has several restrictions:
+Like the :ref:`landingpad <i_landingpad>` instruction, the ``catchpad``
+instruction must be the first non-phi of its parent basic block.
 
--  A catch-end block is a basic block which is the unwind destination of
-   an exceptional instruction.
--  A catch-end block must have a '``catchendpad``' instruction as its
-   first non-PHI instruction.
--  There can be only one '``catchendpad``' instruction within the
-   catch-end block.
--  A basic block that is not a catch-end block may not include a
-   '``catchendpad``' instruction.
--  Exactly one catch block may unwind to a ``catchendpad``.
-- It is undefined behavior to execute a ``catchendpad`` if none of the
-  '``catchpad``'s chained to it have been executed.
-- It is undefined behavior to execute a ``catchendpad`` twice without an
-  intervening execution of one or more of the '``catchpad``'s chained to it.
-- It is undefined behavior to execute a ``catchendpad`` if, after the most
-  recent execution of the normal successor edge of any ``catchpad`` chained
-  to it, some ``catchret`` consuming that ``catchpad`` has already been
-  executed.
-- It is undefined behavior to execute a ``catchendpad`` if, after the most
-  recent execution of the normal successor edge of any ``catchpad`` chained
-  to it, any other ``catchpad`` or ``cleanuppad`` has been executed but has
-  not had a corresponding
-  ``catchret``/``cleanupret``/``catchendpad``/``cleanupendpad`` executed.
+The meaning of the tokens produced and consumed by ``catchpad`` and other "pad"
+instructions is described in the
+`Windows exception handling documentation <ExceptionHandling.html#wineh>`.
+
+Executing a ``catchpad`` instruction constitutes "entering" that pad.
+The pad may then be "exited" in one of three ways:
+1)  explicitly via a ``catchret`` that consumes it.  Executing such a ``catchret``
+    is undefined behavior if any descendant pads have been entered but not yet
+    exited.
+2)  implicitly via a call (which unwinds all the way to the current function's caller),
+    or via a ``catchswitch``, ``cleanupret``, or ``terminatepad`` that unwinds to caller.
+3)  implicitly via an unwind edge whose destination EH pad isn't a descendant of
+    the ``catchpad``.  When the ``catchpad`` is exited in this manner, it is
+    undefined behavior if the destination EH pad has a parent which is not an
+    ancestor of the ``catchpad`` being exited.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
-      catchendpad unwind label %terminate
-      catchendpad unwind to caller
+    dispatch:
+      %cs = catchswitch within none [label %handler0] unwind to caller
+      ;; A catch block which can catch an integer.
+    handler0:
+      %tok = catchpad within %cs [i8** @_ZTIi]
 
 .. _i_catchret:
 
 '``catchret``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      catchret <value> to label <normal>
+      catchret from <token> to label <normal>
 
 Overview:
 """""""""
 
 The '``catchret``' instruction is a terminator instruction that has a
 single successor.
 
 
 Arguments:
 """"""""""
 
 The first argument to a '``catchret``' indicates which ``catchpad`` it
 exits.  It must be a :ref:`catchpad <i_catchpad>`.
 The second argument to a '``catchret``' specifies where control will
 transfer to next.
 
 Semantics:
 """"""""""
 
-The '``catchret``' instruction ends the existing (in-flight) exception
-whose unwinding was interrupted with a
-:ref:`catchpad <i_catchpad>` instruction.
-The :ref:`personality function <personalityfn>` gets a chance to execute
-arbitrary code to, for example, run a C++ destructor.
-Control then transfers to ``normal``.
-It may be passed an optional, personality specific, value.
-
-It is undefined behavior to execute a ``catchret`` whose ``catchpad`` has
-not been executed.
+The '``catchret``' instruction ends an existing (in-flight) exception whose
+unwinding was interrupted with a :ref:`catchpad <i_catchpad>` instruction.  The
+:ref:`personality function <personalityfn>` gets a chance to execute arbitrary
+code to, for example, destroy the active exception.  Control then transfers to
+``normal``.
 
-It is undefined behavior to execute a ``catchret`` if, after the most recent
-execution of its ``catchpad``, some ``catchret`` or ``catchendpad`` linked
-to the same ``catchpad`` has already been executed.
-
-It is undefined behavior to execute a ``catchret`` if, after the most recent
-execution of its ``catchpad``, any other ``catchpad`` or ``cleanuppad`` has
-been executed but has not had a corresponding
-``catchret``/``cleanupret``/``catchendpad``/``cleanupendpad`` executed.
+The ``token`` argument must be a token produced by a dominating ``catchpad``
+instruction. The ``catchret`` destroys the physical frame established by
+``catchpad``, so executing multiple returns on the same token without
+re-executing the ``catchpad`` will result in undefined behavior.
+See :ref:`catchpad <i_catchpad>` for more details.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
-      catchret %catch label %continue
-
-.. _i_cleanupendpad:
-
-'``cleanupendpad``' Instruction
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Syntax:
-"""""""
-
-::
-
-      cleanupendpad <value> unwind label <nextaction>
-      cleanupendpad <value> unwind to caller
-
-Overview:
-"""""""""
-
-The '``cleanupendpad``' instruction is used by `LLVM's exception handling
-system <ExceptionHandling.html#overview>`_ to communicate to the
-:ref:`personality function <personalityfn>` which invokes are associated
-with a :ref:`cleanuppad <i_cleanuppad>` instructions; propagating an exception
-out of a cleanup is represented by unwinding through its ``cleanupendpad``.
-
-The ``nextaction`` label indicates where control should unwind to next, in the
-event that a cleanup is exited by means of an(other) exception being raised.
-
-If a ``nextaction`` label is not present, the instruction unwinds out of
-its parent function. The
-:ref:`personality function <personalityfn>` will continue processing
-exception handling actions in the caller.
-
-Arguments:
-""""""""""
-
-The '``cleanupendpad``' instruction requires one argument, which indicates
-which ``cleanuppad`` it exits, and must be a :ref:`cleanuppad <i_cleanuppad>`.
-It also has an optional successor, ``nextaction``, indicating where control
-should transfer to.
-
-Semantics:
-""""""""""
-
-When and exception propagates to a ``cleanupendpad``, control is transfered to
-``nextaction`` if it is present. If it is not present, control is transfered to
-the caller.
-
-The ``cleanupendpad`` instruction has several restrictions:
-
--  A cleanup-end block is a basic block which is the unwind destination of
-   an exceptional instruction.
--  A cleanup-end block must have a '``cleanupendpad``' instruction as its
-   first non-PHI instruction.
--  There can be only one '``cleanupendpad``' instruction within the
-   cleanup-end block.
--  A basic block that is not a cleanup-end block may not include a
-   '``cleanupendpad``' instruction.
-- It is undefined behavior to execute a ``cleanupendpad`` whose ``cleanuppad``
-  has not been executed.
-- It is undefined behavior to execute a ``cleanupendpad`` if, after the most
-  recent execution of its ``cleanuppad``, some ``cleanupret`` or ``cleanupendpad``
-  consuming the same ``cleanuppad`` has already been executed.
-- It is undefined behavior to execute a ``cleanupendpad`` if, after the most
-  recent execution of its ``cleanuppad``, any other ``cleanuppad`` or
-  ``catchpad`` has been executed but has not had a corresponding
-  ``cleanupret``/``catchret``/``cleanupendpad``/``catchendpad`` executed.
-
-Example:
-""""""""
-
-.. code-block:: llvm
-
-      cleanupendpad %cleanup unwind label %terminate
-      cleanupendpad %cleanup unwind to caller
+      catchret from %catch label %continue
 
 .. _i_cleanupret:
 
 '``cleanupret``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      cleanupret <value> unwind label <continue>
-      cleanupret <value> unwind to caller
+      cleanupret from <value> unwind label <continue>
+      cleanupret from <value> unwind to caller
 
 Overview:
 """""""""
 
 The '``cleanupret``' instruction is a terminator instruction that has
 an optional successor.
 
 
 Arguments:
 """"""""""
 
 The '``cleanupret``' instruction requires one argument, which indicates
 which ``cleanuppad`` it exits, and must be a :ref:`cleanuppad <i_cleanuppad>`.
 It also has an optional successor, ``continue``.
 
 Semantics:
 """"""""""
 
 The '``cleanupret``' instruction indicates to the
 :ref:`personality function <personalityfn>` that one
 :ref:`cleanuppad <i_cleanuppad>` it transferred control to has ended.
 It transfers control to ``continue`` or unwinds out of the function.
 
-It is undefined behavior to execute a ``cleanupret`` whose ``cleanuppad`` has
-not been executed.
-
-It is undefined behavior to execute a ``cleanupret`` if, after the most recent
-execution of its ``cleanuppad``, some ``cleanupret`` or ``cleanupendpad``
-consuming the same ``cleanuppad`` has already been executed.
-
-It is undefined behavior to execute a ``cleanupret`` if, after the most recent
-execution of its ``cleanuppad``, any other ``cleanuppad`` or ``catchpad`` has
-been executed but has not had a corresponding
-``cleanupret``/``catchret``/``cleanupendpad``/``catchendpad`` executed.
+The unwind destination ``continue``, if present, must be an EH pad
+whose parent is either ``none`` or an ancestor of the ``cleanuppad``
+being returned from.  This constitutes an exceptional exit from all
+ancestors of the completed ``cleanuppad``, up to but not including
+the parent of ``continue``.
+See :ref:`cleanuppad <i_cleanuppad>` for more details.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
-      cleanupret %cleanup unwind to caller
-      cleanupret %cleanup unwind label %continue
+      cleanupret from %cleanup unwind to caller
+      cleanupret from %cleanup unwind label %continue
 
 .. _i_terminatepad:
 
 '``terminatepad``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      terminatepad [<args>*] unwind label <exception label>
-      terminatepad [<args>*] unwind to caller
+      terminatepad within <token> [<args>*] unwind label <exception label>
+      terminatepad within <token> [<args>*] unwind to caller
 
 Overview:
 """""""""
 
 The '``terminatepad``' instruction is used by `LLVM's exception handling
 system <ExceptionHandling.html#overview>`_ to specify that a basic block
 is a terminate block --- one where a personality routine may decide to
 terminate the program.

 
 When the call stack is being unwound due to an exception being thrown,
 the exception is compared against the ``args``. If it matches,
 then control is transfered to the ``exception`` basic block. Otherwise,
 the program is terminated via personality-specific means. Typically,
 the first argument to ``terminatepad`` specifies what function the
 personality should defer to in order to terminate the program.
 
-The ``terminatepad`` instruction has several restrictions:
-
--  A terminate block is a basic block which is the unwind destination of
-   an exceptional instruction.
--  A terminate block must have a '``terminatepad``' instruction as its
-   first non-PHI instruction.
--  There can be only one '``terminatepad``' instruction within the
-   terminate block.
--  A basic block that is not a terminate block may not include a
-   '``terminatepad``' instruction.
+The ``terminatepad`` instruction is both a terminator and a "pad" instruction,
+meaning that is always the only non-phi instruction in the basic block.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
       ;; A terminate block which only permits integers.
-      terminatepad [i8** @_ZTIi] unwind label %continue
+      terminatepad within none [i8** @_ZTIi] unwind label %continue
 
 .. _i_unreachable:
 
 '``unreachable``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""

 '``cleanuppad``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      <resultval> = cleanuppad [<args>*]
+      <resultval> = cleanuppad within <parent> [<args>*]
 
 Overview:
 """""""""
 
 The '``cleanuppad``' instruction is used by `LLVM's exception handling
 system <ExceptionHandling.html#overview>`_ to specify that a basic block
 is a cleanup block --- one where a personality routine attempts to
 transfer control to run cleanup actions.
 The ``args`` correspond to whatever additional
 information the :ref:`personality function <personalityfn>` requires to
 execute the cleanup.
 The ``resultval`` has the type :ref:`token <t_token>` and is used to
-match the ``cleanuppad`` to corresponding :ref:`cleanuprets <i_cleanupret>`
-and :ref:`cleanupendpads <i_cleanupendpad>`.
+match the ``cleanuppad`` to corresponding :ref:`cleanuprets <i_cleanupret>`.
+The ``parent`` argument is the token of the funclet that contains the
+``cleanuppad`` instruction. If the ``cleanuppad`` is not inside a funclet,
+this operand may be the token ``none``.
 
 Arguments:
 """"""""""
 
 The instruction takes a list of arbitrary values which are interpreted
 by the :ref:`personality function <personalityfn>`.
 
 Semantics:

 -  A cleanup block is a basic block which is the unwind destination of
    an exceptional instruction.
 -  A cleanup block must have a '``cleanuppad``' instruction as its
    first non-PHI instruction.
 -  There can be only one '``cleanuppad``' instruction within the
    cleanup block.
 -  A basic block that is not a cleanup block may not include a
    '``cleanuppad``' instruction.
--  All '``cleanupret``'s and '``cleanupendpad``'s which consume a ``cleanuppad``
-   must have the same exceptional successor.
--  It is undefined behavior for control to transfer from a ``cleanuppad`` to a
-   ``ret`` without first executing a ``cleanupret`` or ``cleanupendpad`` that
-   consumes the ``cleanuppad``.
--  It is undefined behavior for control to transfer from a ``cleanuppad`` to
-   itself without first executing a ``cleanupret`` or ``cleanupendpad`` that
-   consumes the ``cleanuppad``.
+
+Executing a ``cleanuppad`` instruction constitutes "entering" that pad.
+The pad may then be "exited" in one of three ways:
+1)  explicitly via a ``cleanupret`` that consumes it.  Executing such a ``cleanupret``
+    is undefined behavior if any descendant pads have been entered but not yet
+    exited.
+2)  implicitly via a call (which unwinds all the way to the current function's caller),
+    or via a ``catchswitch``, ``cleanupret``, or ``terminatepad`` that unwinds to caller.
+3)  implicitly via an unwind edge whose destination EH pad isn't a descendant of
+    the ``cleanuppad``.  When the ``cleanuppad`` is exited in this manner, it is
+    undefined behavior if the destination EH pad has a parent which is not an
+    ancestor of the ``cleanuppad`` being exited.
+
+It is undefined behavior for the ``cleanuppad`` to exit via an unwind edge which
+does not transitively unwind to the same destination as a constituent
+``cleanupret``.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
-      %tok = cleanuppad []
+      %tok = cleanuppad within %cs []
 
 .. _intrinsics:
 
 Intrinsic Functions
 ===================
 
 LLVM supports the notion of an "intrinsic function". These functions
 have well known names and semantics and are required to follow certain

llvm/trunk/include/llvm-c/Core.h

typedef enum {
   /* Exception Handling Operators */
   LLVMResume         = 58,
   LLVMLandingPad     = 59,
   LLVMCleanupRet     = 61,
   LLVMCatchRet       = 62,
   LLVMCatchPad       = 63,
   LLVMTerminatePad   = 64,
   LLVMCleanupPad     = 65,
-  LLVMCatchEndPad    = 66,
-  LLVMCleanupEndPad  = 67
+  LLVMCatchSwitch    = 66
 } LLVMOpcode;
 
 typedef enum {
   LLVMVoidTypeKind,        /**< type with no size */
   LLVMHalfTypeKind,        /**< 16 bit floating point type */
   LLVMFloatTypeKind,       /**< 32 bit floating point type */
   LLVMDoubleTypeKind,      /**< 64 bit floating point type */
   LLVMX86_FP80TypeKind,    /**< 80 bit floating point type (X87) */
macro(Instruction)                      \
       macro(CmpInst)                        \
         macro(FCmpInst)                     \
         macro(ICmpInst)                     \
       macro(ExtractElementInst)             \
       macro(GetElementPtrInst)              \
       macro(InsertElementInst)              \
       macro(InsertValueInst)                \
       macro(LandingPadInst)                 \
-      macro(CleanupPadInst)                 \
       macro(PHINode)                        \
       macro(SelectInst)                     \
       macro(ShuffleVectorInst)              \
       macro(StoreInst)                      \
       macro(TerminatorInst)                 \
         macro(BranchInst)                   \
         macro(IndirectBrInst)               \
         macro(InvokeInst)                   \
         macro(ReturnInst)                   \
         macro(SwitchInst)                   \
         macro(UnreachableInst)              \
         macro(ResumeInst)                   \
         macro(CleanupReturnInst)            \
         macro(CatchReturnInst)              \
-        macro(CatchPadInst)                 \
         macro(TerminatePadInst)             \
-        macro(CatchEndPadInst)              \
-        macro(CleanupEndPadInst)            \
+      macro(FuncletPadInst)                 \
+        macro(CatchPadInst)                 \
+        macro(CleanupPadInst)               \
       macro(UnaryInstruction)               \
         macro(AllocaInst)                   \
         macro(CastInst)                     \
           macro(AddrSpaceCastInst)          \
           macro(BitCastInst)                \
           macro(FPExtInst)                  \
           macro(FPToSIInst)                 \
           macro(FPToUIInst)                 \

llvm/trunk/include/llvm/Analysis/EHPersonalities.h

 //===- EHPersonalities.h - Compute EH-related information -----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_EHPERSONALITIES_H
 #define LLVM_ANALYSIS_EHPERSONALITIES_H
 
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace llvm {
+class BasicBlock;
 class Function;
 class Value;
 
 enum class EHPersonality {
   Unknown,
   GNU_Ada,
   GNU_C,
   GNU_CXX,
inline bool isNoOpWithoutInvoke(EHPersonality Pers) {
   default:
     return true;
   }
   llvm_unreachable("invalid enum");
 }
 
 bool canSimplifyInvokeNoUnwind(const Function *F);
 
+typedef TinyPtrVector<BasicBlock *> ColorVector;
+
+/// \brief If an EH funclet personality is in use (see isFuncletEHPersonality),
+/// this will recompute which blocks are in which funclet. It is possible that
+/// some blocks are in multiple funclets. Consider this analysis to be
+/// expensive.
+DenseMap<BasicBlock *, ColorVector> colorEHFunclets(Function &F);
+
 } // end namespace llvm
 
 #endif

llvm/trunk/include/llvm/Bitcode/LLVMBitCodes.h

enum FunctionCodes {
     FUNC_CODE_INST_CMPXCHG     = 46, // CMPXCHG: [ptrty,ptr,valty,cmp,new, align,
                                      //           vol,ordering,synchscope]
     FUNC_CODE_INST_LANDINGPAD  = 47, // LANDINGPAD: [ty,val,num,id0,val0...]
     FUNC_CODE_INST_CLEANUPRET  = 48, // CLEANUPRET: [val] or [val,bb#]
     FUNC_CODE_INST_CATCHRET    = 49, // CATCHRET: [val,bb#]
     FUNC_CODE_INST_CATCHPAD  = 50, // CATCHPAD: [bb#,bb#,num,args...]
     FUNC_CODE_INST_TERMINATEPAD = 51, // TERMINATEPAD: [bb#,num,args...]
     FUNC_CODE_INST_CLEANUPPAD = 52, // CLEANUPPAD: [num,args...]
-    FUNC_CODE_INST_CATCHENDPAD = 53, // CATCHENDPAD: [] or [bb#]
-    FUNC_CODE_INST_CLEANUPENDPAD = 54, // CLEANUPENDPAD: [val] or [val,bb#]
-
+    FUNC_CODE_INST_CATCHSWITCH = 53, // CATCHSWITCH: [num,args...] or [num,args...,bb]
+    // 54 is unused.
     FUNC_CODE_OPERAND_BUNDLE = 55, // OPERAND_BUNDLE: [tag#, value...]
   };
 
   enum UseListCodes {
     USELIST_CODE_DEFAULT = 1, // DEFAULT: [index..., value-id]
     USELIST_CODE_BB      = 2  // BB: [index..., bb-id]
   };
 

llvm/trunk/include/llvm/CodeGen/WinEHFuncInfo.h

struct ClrEHUnwindMapEntry {
   MBBOrBasicBlock Handler;
   uint32_t TypeToken;
   int Parent;
   ClrHandlerType HandlerType;
 };
 
 struct WinEHFuncInfo {
   DenseMap<const Instruction *, int> EHPadStateMap;
+  DenseMap<const FuncletPadInst *, int> FuncletBaseStateMap;
+  DenseMap<const InvokeInst *, int> InvokeStateMap;
   DenseMap<const CatchReturnInst *, const BasicBlock *>
       CatchRetSuccessorColorMap;
-  DenseMap<MCSymbol *, std::pair<int, MCSymbol *>> InvokeToStateMap;
+  DenseMap<MCSymbol *, std::pair<int, MCSymbol *>> LabelToStateMap;
   SmallVector<CxxUnwindMapEntry, 4> CxxUnwindMap;
   SmallVector<WinEHTryBlockMapEntry, 4> TryBlockMap;
   SmallVector<SEHUnwindMapEntry, 4> SEHUnwindMap;
   SmallVector<ClrEHUnwindMapEntry, 4> ClrEHUnwindMap;
   int UnwindHelpFrameIdx = INT_MAX;
   int PSPSymFrameIdx = INT_MAX;
 
   int getLastStateNumber() const { return CxxUnwindMap.size() - 1; }
 
-  void addIPToStateRange(const BasicBlock *PadBB, MCSymbol *InvokeBegin,
+  void addIPToStateRange(const InvokeInst *II, MCSymbol *InvokeBegin,
                          MCSymbol *InvokeEnd);
 
   int EHRegNodeFrameIndex = INT_MAX;
   int EHRegNodeEndOffset = INT_MAX;
 
   WinEHFuncInfo() {}
 };
 

llvm/trunk/include/llvm/IR/IRBuilder.h

ResumeInst *CreateResume(Value *Exn) {
     return Insert(ResumeInst::Create(Exn));
   }
 
   CleanupReturnInst *CreateCleanupRet(CleanupPadInst *CleanupPad,
                                       BasicBlock *UnwindBB = nullptr) {
     return Insert(CleanupReturnInst::Create(CleanupPad, UnwindBB));
   }
 
-  CleanupEndPadInst *CreateCleanupEndPad(CleanupPadInst *CleanupPad,
-                                         BasicBlock *UnwindBB = nullptr) {
-    return Insert(CleanupEndPadInst::Create(CleanupPad, UnwindBB));
-  }
-
-  CatchPadInst *CreateCatchPad(BasicBlock *NormalDest, BasicBlock *UnwindDest,
-                               ArrayRef<Value *> Args, const Twine &Name = "") {
-    return Insert(CatchPadInst::Create(NormalDest, UnwindDest, Args), Name);
+  CatchSwitchInst *CreateCatchSwitch(Value *ParentPad, BasicBlock *UnwindBB,
+                                     unsigned NumHandlers,
+                                     const Twine &Name = "") {
+    return Insert(CatchSwitchInst::Create(ParentPad, UnwindBB, NumHandlers),
+                  Name);
   }
 
-  CatchEndPadInst *CreateCatchEndPad(BasicBlock *UnwindBB = nullptr) {
-    return Insert(CatchEndPadInst::Create(Context, UnwindBB));
+  CatchPadInst *CreateCatchPad(Value *ParentPad, ArrayRef<Value *> Args,
+                               const Twine &Name = "") {
+    return Insert(CatchPadInst::Create(ParentPad, Args), Name);
   }
 
-  TerminatePadInst *CreateTerminatePad(BasicBlock *UnwindBB = nullptr,
-                                       ArrayRef<Value *> Args = {},
+  TerminatePadInst *CreateTerminatePad(Value *ParentPad,
+                                       BasicBlock *UnwindBB = nullptr,
+                                       ArrayRef<Value *> Args = None,
                                        const Twine &Name = "") {
-    return Insert(TerminatePadInst::Create(Context, UnwindBB, Args), Name);
+    return Insert(TerminatePadInst::Create(ParentPad, UnwindBB, Args), Name);
   }
 
-  CleanupPadInst *CreateCleanupPad(ArrayRef<Value *> Args,
+  CleanupPadInst *CreateCleanupPad(Value *ParentPad,
+                                   ArrayRef<Value *> Args = None,
                                    const Twine &Name = "") {
-    return Insert(CleanupPadInst::Create(Context, Args), Name);
+    return Insert(CleanupPadInst::Create(ParentPad, Args), Name);
   }
 
   CatchReturnInst *CreateCatchRet(CatchPadInst *CatchPad, BasicBlock *BB) {
     return Insert(CatchReturnInst::Create(CatchPad, BB));
   }
 
   UnreachableInst *CreateUnreachable() {
     return Insert(new UnreachableInst(Context));

llvm/trunk/include/llvm/IR/InstVisitor.h

#include "llvm/IR/Instruction.def"
   //
   RetTy visitReturnInst(ReturnInst &I)            { DELEGATE(TerminatorInst);}
   RetTy visitBranchInst(BranchInst &I)            { DELEGATE(TerminatorInst);}
   RetTy visitSwitchInst(SwitchInst &I)            { DELEGATE(TerminatorInst);}
   RetTy visitIndirectBrInst(IndirectBrInst &I)    { DELEGATE(TerminatorInst);}
   RetTy visitResumeInst(ResumeInst &I)            { DELEGATE(TerminatorInst);}
   RetTy visitUnreachableInst(UnreachableInst &I)  { DELEGATE(TerminatorInst);}
   RetTy visitCleanupReturnInst(CleanupReturnInst &I) { DELEGATE(TerminatorInst);}
-  RetTy visitCleanupEndPadInst(CleanupEndPadInst &I) { DELEGATE(TerminatorInst); }
   RetTy visitCatchReturnInst(CatchReturnInst &I)  { DELEGATE(TerminatorInst); }
-  RetTy visitCatchPadInst(CatchPadInst &I)    { DELEGATE(TerminatorInst);}
-  RetTy visitCatchEndPadInst(CatchEndPadInst &I) { DELEGATE(TerminatorInst); }
+  RetTy visitCatchSwitchInst(CatchSwitchInst &I)  { DELEGATE(TerminatorInst);}
   RetTy visitTerminatePadInst(TerminatePadInst &I) { DELEGATE(TerminatorInst);}
   RetTy visitICmpInst(ICmpInst &I)                { DELEGATE(CmpInst);}
   RetTy visitFCmpInst(FCmpInst &I)                { DELEGATE(CmpInst);}
   RetTy visitAllocaInst(AllocaInst &I)            { DELEGATE(UnaryInstruction);}
   RetTy visitLoadInst(LoadInst     &I)            { DELEGATE(UnaryInstruction);}
   RetTy visitStoreInst(StoreInst   &I)            { DELEGATE(Instruction);}
   RetTy visitAtomicCmpXchgInst(AtomicCmpXchgInst &I) { DELEGATE(Instruction);}
   RetTy visitAtomicRMWInst(AtomicRMWInst &I)      { DELEGATE(Instruction);}
#include "llvm/IR/Instruction.def"
   RetTy visitSelectInst(SelectInst &I)            { DELEGATE(Instruction);}
   RetTy visitVAArgInst(VAArgInst   &I)            { DELEGATE(UnaryInstruction);}
   RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction);}
   RetTy visitInsertElementInst(InsertElementInst &I) { DELEGATE(Instruction);}
   RetTy visitShuffleVectorInst(ShuffleVectorInst &I) { DELEGATE(Instruction);}
   RetTy visitExtractValueInst(ExtractValueInst &I){ DELEGATE(UnaryInstruction);}
   RetTy visitInsertValueInst(InsertValueInst &I)  { DELEGATE(Instruction); }
   RetTy visitLandingPadInst(LandingPadInst &I)    { DELEGATE(Instruction); }
-  RetTy visitCleanupPadInst(CleanupPadInst &I) { DELEGATE(Instruction); }
+  RetTy visitFuncletPadInst(FuncletPadInst &I) { DELEGATE(Instruction); }
+  RetTy visitCleanupPadInst(CleanupPadInst &I) { DELEGATE(FuncletPadInst); }
+  RetTy visitCatchPadInst(CatchPadInst &I)     { DELEGATE(FuncletPadInst); }
 
   // Handle the special instrinsic instruction classes.
   RetTy visitDbgDeclareInst(DbgDeclareInst &I)    { DELEGATE(DbgInfoIntrinsic);}
   RetTy visitDbgValueInst(DbgValueInst &I)        { DELEGATE(DbgInfoIntrinsic);}
   RetTy visitDbgInfoIntrinsic(DbgInfoIntrinsic &I) { DELEGATE(IntrinsicInst); }
   RetTy visitMemSetInst(MemSetInst &I)            { DELEGATE(MemIntrinsic); }
   RetTy visitMemCpyInst(MemCpyInst &I)            { DELEGATE(MemTransferInst); }
   RetTy visitMemMoveInst(MemMoveInst &I)          { DELEGATE(MemTransferInst); }

llvm/trunk/include/llvm/IR/InstrTypes.h

public:
   }
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
   // \brief Returns true if this terminator relates to exception handling.
   bool isExceptional() const {
     switch (getOpcode()) {
-    case Instruction::CatchPad:
-    case Instruction::CatchEndPad:
+    case Instruction::CatchSwitch:
     case Instruction::CatchRet:
-    case Instruction::CleanupEndPad:
     case Instruction::CleanupRet:
     case Instruction::Invoke:
     case Instruction::Resume:
     case Instruction::TerminatePad:
       return true;
     default:
       return false;
     }

 
 // FIXME: these are redundant if CmpInst < BinaryOperator
 template <>
 struct OperandTraits<CmpInst> : public FixedNumOperandTraits<CmpInst, 2> {
 };
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CmpInst, Value)
 
+//===----------------------------------------------------------------------===//
+//                           FuncletPadInst Class
+//===----------------------------------------------------------------------===//
+class FuncletPadInst : public Instruction {
+private:
+  void init(Value *ParentPad, ArrayRef<Value *> Args, const Twine &NameStr);
+
+  FuncletPadInst(const FuncletPadInst &CPI);
+
+  explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
+                          ArrayRef<Value *> Args, unsigned Values,
+                          const Twine &NameStr, Instruction *InsertBefore);
+  explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
+                          ArrayRef<Value *> Args, unsigned Values,
+                          const Twine &NameStr, BasicBlock *InsertAtEnd);
+
+protected:
+  // Note: Instruction needs to be a friend here to call cloneImpl.
+  friend class Instruction;
+  friend class CatchPadInst;
+  friend class CleanupPadInst;
+  FuncletPadInst *cloneImpl() const;
+
+public:
+  /// Provide fast operand accessors
+  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
+
+  /// getNumArgOperands - Return the number of funcletpad arguments.
+  ///
+  unsigned getNumArgOperands() const { return getNumOperands() - 1; }
+
+  /// Convenience accessors
+
+  /// \brief Return the outer EH-pad this funclet is nested within.
+  ///
+  /// Note: This returns the associated CatchSwitchInst if this FuncletPadInst
+  /// is a CatchPadInst.
+  Value *getParentPad() const { return Op<-1>(); }
+  void setParentPad(Value *ParentPad) {
+    assert(ParentPad);
+    Op<-1>() = ParentPad;
+  }
+
+  /// getArgOperand/setArgOperand - Return/set the i-th funcletpad argument.
+  ///
+  Value *getArgOperand(unsigned i) const { return getOperand(i); }
+  void setArgOperand(unsigned i, Value *v) { setOperand(i, v); }
+
+  /// arg_operands - iteration adapter for range-for loops.
+  op_range arg_operands() { return op_range(op_begin(), op_end() - 1); }
+
+  /// arg_operands - iteration adapter for range-for loops.
+  const_op_range arg_operands() const {
+    return const_op_range(op_begin(), op_end() - 1);
+  }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const Instruction *I) { return I->isFuncletPad(); }
+  static inline bool classof(const Value *V) {
+    return isa<Instruction>(V) && classof(cast<Instruction>(V));
+  }
+};
+
+template <>
+struct OperandTraits<FuncletPadInst>
+    : public VariadicOperandTraits<FuncletPadInst, /*MINARITY=*/1> {};
+
+DEFINE_TRANSPARENT_OPERAND_ACCESSORS(FuncletPadInst, Value)
+
 /// \brief A lightweight accessor for an operand bundle meant to be passed
 /// around by value.
 struct OperandBundleUse {
   ArrayRef<Use> Inputs;
 
   OperandBundleUse() {}
   explicit OperandBundleUse(StringMapEntry<uint32_t> *Tag, ArrayRef<Use> Inputs)
       : Inputs(Inputs), Tag(Tag) {}

llvm/trunk/include/llvm/IR/Instruction.h

public:
   /// getOpcode() returns a member of one of the enums like Instruction::Add.
   unsigned getOpcode() const { return getValueID() - InstructionVal; }
 
   const char *getOpcodeName() const { return getOpcodeName(getOpcode()); }
   bool isTerminator() const { return isTerminator(getOpcode()); }
   bool isBinaryOp() const { return isBinaryOp(getOpcode()); }
   bool isShift() { return isShift(getOpcode()); }
   bool isCast() const { return isCast(getOpcode()); }
+  bool isFuncletPad() const { return isFuncletPad(getOpcode()); }
 
   static const char* getOpcodeName(unsigned OpCode);
 
   static inline bool isTerminator(unsigned OpCode) {
     return OpCode >= TermOpsBegin && OpCode < TermOpsEnd;
   }
 
   static inline bool isBinaryOp(unsigned Opcode) {
inline bool isArithmeticShift() const {
     return getOpcode() == AShr;
   }
 
   /// @brief Determine if the OpCode is one of the CastInst instructions.
   static inline bool isCast(unsigned OpCode) {
     return OpCode >= CastOpsBegin && OpCode < CastOpsEnd;
   }
 
+  /// @brief Determine if the OpCode is one of the FuncletPadInst instructions.
+  static inline bool isFuncletPad(unsigned OpCode) {
+    return OpCode >= FuncletPadOpsBegin && OpCode < FuncletPadOpsEnd;
+  }
+
   //===--------------------------------------------------------------------===//
   // Metadata manipulation.
   //===--------------------------------------------------------------------===//
 
   /// hasMetadata() - Return true if this instruction has any metadata attached
   /// to it.
   bool hasMetadata() const { return DbgLoc || hasMetadataHashEntry(); }
 
public:
   /// matters, isSafeToSpeculativelyExecute may be more appropriate.
   bool mayHaveSideEffects() const {
     return mayWriteToMemory() || mayThrow() || !mayReturn();
   }
 
   /// \brief Return true if the instruction is a variety of EH-block.
   bool isEHPad() const {
     switch (getOpcode()) {
+    case Instruction::CatchSwitch:
     case Instruction::CatchPad:
-    case Instruction::CatchEndPad:
     case Instruction::CleanupPad:
-    case Instruction::CleanupEndPad:
     case Instruction::LandingPad:
     case Instruction::TerminatePad:
       return true;
     default:
       return false;
     }
   }
 
#include "llvm/IR/Instruction.def"
 
   enum CastOps {
 #define  FIRST_CAST_INST(N)             CastOpsBegin = N,
 #define HANDLE_CAST_INST(N, OPC, CLASS) OPC = N,
 #define   LAST_CAST_INST(N)             CastOpsEnd = N+1
 #include "llvm/IR/Instruction.def"
   };
 
+  enum FuncletPadOps {
+#define  FIRST_FUNCLETPAD_INST(N)             FuncletPadOpsBegin = N,
+#define HANDLE_FUNCLETPAD_INST(N, OPC, CLASS) OPC = N,
+#define   LAST_FUNCLETPAD_INST(N)             FuncletPadOpsEnd = N+1
+#include "llvm/IR/Instruction.def"
+  };
+
   enum OtherOps {
 #define  FIRST_OTHER_INST(N)             OtherOpsBegin = N,
 #define HANDLE_OTHER_INST(N, OPC, CLASS) OPC = N,
 #define   LAST_OTHER_INST(N)             OtherOpsEnd = N+1
 #include "llvm/IR/Instruction.def"
   };
 private:
   // Shadow Value::setValueSubclassData with a private forwarding method so that

llvm/trunk/include/llvm/IR/Instruction.def

 #else
 #define HANDLE_CAST_INST(num, opcode, Class) HANDLE_INST(num, opcode, Class)
 #endif
 #endif
 #ifndef LAST_CAST_INST
 #define LAST_CAST_INST(num)
 #endif
 
+#ifndef FIRST_FUNCLETPAD_INST
+#define FIRST_FUNCLETPAD_INST(num)
+#endif
+#ifndef HANDLE_FUNCLETPAD_INST
+#ifndef HANDLE_INST
+#define HANDLE_FUNCLETPAD_INST(num, opcode, Class)
+#else
+#define HANDLE_FUNCLETPAD_INST(num, opcode, Class) HANDLE_INST(num, opcode, Class)
+#endif
+#endif
+#ifndef LAST_FUNCLETPAD_INST
+#define LAST_FUNCLETPAD_INST(num)
+#endif
+
 #ifndef FIRST_OTHER_INST
 #define FIRST_OTHER_INST(num)
 #endif
 #ifndef HANDLE_OTHER_INST
 #ifndef HANDLE_INST
 #define HANDLE_OTHER_INST(num, opcode, Class)
 #else
 #define HANDLE_OTHER_INST(num, opcode, Class) HANDLE_INST(num, opcode, Class)

 HANDLE_TERM_INST  ( 2, Br            , BranchInst)
 HANDLE_TERM_INST  ( 3, Switch        , SwitchInst)
 HANDLE_TERM_INST  ( 4, IndirectBr    , IndirectBrInst)
 HANDLE_TERM_INST  ( 5, Invoke        , InvokeInst)
 HANDLE_TERM_INST  ( 6, Resume        , ResumeInst)
 HANDLE_TERM_INST  ( 7, Unreachable   , UnreachableInst)
 HANDLE_TERM_INST  ( 8, CleanupRet    , CleanupReturnInst)
 HANDLE_TERM_INST  ( 9, CatchRet      , CatchReturnInst)
-HANDLE_TERM_INST  (10, CatchPad      , CatchPadInst)
+HANDLE_TERM_INST  (10, CatchSwitch   , CatchSwitchInst)
 HANDLE_TERM_INST  (11, TerminatePad  , TerminatePadInst)
-HANDLE_TERM_INST  (12, CatchEndPad   , CatchEndPadInst)
-HANDLE_TERM_INST  (13, CleanupEndPad , CleanupEndPadInst)
-  LAST_TERM_INST  (13)
+  LAST_TERM_INST  (11)
 
 // Standard binary operators...
- FIRST_BINARY_INST(14)
-HANDLE_BINARY_INST(14, Add  , BinaryOperator)
-HANDLE_BINARY_INST(15, FAdd , BinaryOperator)
-HANDLE_BINARY_INST(16, Sub  , BinaryOperator)
-HANDLE_BINARY_INST(17, FSub , BinaryOperator)
-HANDLE_BINARY_INST(18, Mul  , BinaryOperator)
-HANDLE_BINARY_INST(19, FMul , BinaryOperator)
-HANDLE_BINARY_INST(20, UDiv , BinaryOperator)
-HANDLE_BINARY_INST(21, SDiv , BinaryOperator)
-HANDLE_BINARY_INST(22, FDiv , BinaryOperator)
-HANDLE_BINARY_INST(23, URem , BinaryOperator)
-HANDLE_BINARY_INST(24, SRem , BinaryOperator)
-HANDLE_BINARY_INST(25, FRem , BinaryOperator)
+ FIRST_BINARY_INST(12)
+HANDLE_BINARY_INST(12, Add  , BinaryOperator)
+HANDLE_BINARY_INST(13, FAdd , BinaryOperator)
+HANDLE_BINARY_INST(14, Sub  , BinaryOperator)
+HANDLE_BINARY_INST(15, FSub , BinaryOperator)
+HANDLE_BINARY_INST(16, Mul  , BinaryOperator)
+HANDLE_BINARY_INST(17, FMul , BinaryOperator)
+HANDLE_BINARY_INST(18, UDiv , BinaryOperator)
+HANDLE_BINARY_INST(19, SDiv , BinaryOperator)
+HANDLE_BINARY_INST(20, FDiv , BinaryOperator)
+HANDLE_BINARY_INST(21, URem , BinaryOperator)
+HANDLE_BINARY_INST(22, SRem , BinaryOperator)
+HANDLE_BINARY_INST(23, FRem , BinaryOperator)
 
 // Logical operators (integer operands)
-HANDLE_BINARY_INST(26, Shl  , BinaryOperator) // Shift left  (logical)
-HANDLE_BINARY_INST(27, LShr , BinaryOperator) // Shift right (logical)
-HANDLE_BINARY_INST(28, AShr , BinaryOperator) // Shift right (arithmetic)
-HANDLE_BINARY_INST(29, And  , BinaryOperator)
-HANDLE_BINARY_INST(30, Or   , BinaryOperator)
-HANDLE_BINARY_INST(31, Xor  , BinaryOperator)
-  LAST_BINARY_INST(31)
+HANDLE_BINARY_INST(24, Shl  , BinaryOperator) // Shift left  (logical)
+HANDLE_BINARY_INST(25, LShr , BinaryOperator) // Shift right (logical)
+HANDLE_BINARY_INST(26, AShr , BinaryOperator) // Shift right (arithmetic)
+HANDLE_BINARY_INST(27, And  , BinaryOperator)
+HANDLE_BINARY_INST(28, Or   , BinaryOperator)
+HANDLE_BINARY_INST(29, Xor  , BinaryOperator)
+  LAST_BINARY_INST(29)
 
 // Memory operators...
- FIRST_MEMORY_INST(32)
-HANDLE_MEMORY_INST(32, Alloca, AllocaInst)  // Stack management
-HANDLE_MEMORY_INST(33, Load  , LoadInst  )  // Memory manipulation instrs
-HANDLE_MEMORY_INST(34, Store , StoreInst )
-HANDLE_MEMORY_INST(35, GetElementPtr, GetElementPtrInst)
-HANDLE_MEMORY_INST(36, Fence , FenceInst )
-HANDLE_MEMORY_INST(37, AtomicCmpXchg , AtomicCmpXchgInst )
-HANDLE_MEMORY_INST(38, AtomicRMW , AtomicRMWInst )
-  LAST_MEMORY_INST(38)
+ FIRST_MEMORY_INST(30)
+HANDLE_MEMORY_INST(30, Alloca, AllocaInst)  // Stack management
+HANDLE_MEMORY_INST(31, Load  , LoadInst  )  // Memory manipulation instrs
+HANDLE_MEMORY_INST(32, Store , StoreInst )
+HANDLE_MEMORY_INST(33, GetElementPtr, GetElementPtrInst)
+HANDLE_MEMORY_INST(34, Fence , FenceInst )
+HANDLE_MEMORY_INST(35, AtomicCmpXchg , AtomicCmpXchgInst )
+HANDLE_MEMORY_INST(36, AtomicRMW , AtomicRMWInst )
+  LAST_MEMORY_INST(36)
 
 // Cast operators ...
 // NOTE: The order matters here because CastInst::isEliminableCastPair
 // NOTE: (see Instructions.cpp) encodes a table based on this ordering.
- FIRST_CAST_INST(39)
-HANDLE_CAST_INST(39, Trunc   , TruncInst   )  // Truncate integers
-HANDLE_CAST_INST(40, ZExt    , ZExtInst    )  // Zero extend integers
-HANDLE_CAST_INST(41, SExt    , SExtInst    )  // Sign extend integers
-HANDLE_CAST_INST(42, FPToUI  , FPToUIInst  )  // floating point -> UInt
-HANDLE_CAST_INST(43, FPToSI  , FPToSIInst  )  // floating point -> SInt
-HANDLE_CAST_INST(44, UIToFP  , UIToFPInst  )  // UInt -> floating point
-HANDLE_CAST_INST(45, SIToFP  , SIToFPInst  )  // SInt -> floating point
-HANDLE_CAST_INST(46, FPTrunc , FPTruncInst )  // Truncate floating point
-HANDLE_CAST_INST(47, FPExt   , FPExtInst   )  // Extend floating point
-HANDLE_CAST_INST(48, PtrToInt, PtrToIntInst)  // Pointer -> Integer
-HANDLE_CAST_INST(49, IntToPtr, IntToPtrInst)  // Integer -> Pointer
-HANDLE_CAST_INST(50, BitCast , BitCastInst )  // Type cast
-HANDLE_CAST_INST(51, AddrSpaceCast, AddrSpaceCastInst)  // addrspace cast
-  LAST_CAST_INST(51)
+ FIRST_CAST_INST(37)
+HANDLE_CAST_INST(37, Trunc   , TruncInst   )  // Truncate integers
+HANDLE_CAST_INST(38, ZExt    , ZExtInst    )  // Zero extend integers
+HANDLE_CAST_INST(39, SExt    , SExtInst    )  // Sign extend integers
+HANDLE_CAST_INST(40, FPToUI  , FPToUIInst  )  // floating point -> UInt
+HANDLE_CAST_INST(41, FPToSI  , FPToSIInst  )  // floating point -> SInt
+HANDLE_CAST_INST(42, UIToFP  , UIToFPInst  )  // UInt -> floating point
+HANDLE_CAST_INST(43, SIToFP  , SIToFPInst  )  // SInt -> floating point
+HANDLE_CAST_INST(44, FPTrunc , FPTruncInst )  // Truncate floating point
+HANDLE_CAST_INST(45, FPExt   , FPExtInst   )  // Extend floating point
+HANDLE_CAST_INST(46, PtrToInt, PtrToIntInst)  // Pointer -> Integer
+HANDLE_CAST_INST(47, IntToPtr, IntToPtrInst)  // Integer -> Pointer
+HANDLE_CAST_INST(48, BitCast , BitCastInst )  // Type cast
+HANDLE_CAST_INST(49, AddrSpaceCast, AddrSpaceCastInst)  // addrspace cast
+  LAST_CAST_INST(49)
+
+ FIRST_FUNCLETPAD_INST(50)
+HANDLE_FUNCLETPAD_INST(50, CleanupPad, CleanupPadInst)
+HANDLE_FUNCLETPAD_INST(51, CatchPad  , CatchPadInst)
+  LAST_FUNCLETPAD_INST(51)
 
 // Other operators...
  FIRST_OTHER_INST(52)
 HANDLE_OTHER_INST(52, ICmp   , ICmpInst   )  // Integer comparison instruction
 HANDLE_OTHER_INST(53, FCmp   , FCmpInst   )  // Floating point comparison instr.
 HANDLE_OTHER_INST(54, PHI    , PHINode    )  // PHI node instruction
 HANDLE_OTHER_INST(55, Call   , CallInst   )  // Call a function
 HANDLE_OTHER_INST(56, Select , SelectInst )  // select instruction
 HANDLE_OTHER_INST(57, UserOp1, Instruction)  // May be used internally in a pass
 HANDLE_OTHER_INST(58, UserOp2, Instruction)  // Internal to passes only
 HANDLE_OTHER_INST(59, VAArg  , VAArgInst  )  // vaarg instruction
 HANDLE_OTHER_INST(60, ExtractElement, ExtractElementInst)// extract from vector
 HANDLE_OTHER_INST(61, InsertElement, InsertElementInst)  // insert into vector
 HANDLE_OTHER_INST(62, ShuffleVector, ShuffleVectorInst)  // shuffle two vectors.
 HANDLE_OTHER_INST(63, ExtractValue, ExtractValueInst)// extract from aggregate
 HANDLE_OTHER_INST(64, InsertValue, InsertValueInst)  // insert into aggregate
 HANDLE_OTHER_INST(65, LandingPad, LandingPadInst)  // Landing pad instruction.
-HANDLE_OTHER_INST(66, CleanupPad, CleanupPadInst)
-  LAST_OTHER_INST(66)
+  LAST_OTHER_INST(65)
 
 #undef  FIRST_TERM_INST
 #undef HANDLE_TERM_INST
 #undef   LAST_TERM_INST
 
 #undef  FIRST_BINARY_INST
 #undef HANDLE_BINARY_INST
 #undef   LAST_BINARY_INST
 
 #undef  FIRST_MEMORY_INST
 #undef HANDLE_MEMORY_INST
 #undef   LAST_MEMORY_INST
 
 #undef  FIRST_CAST_INST
 #undef HANDLE_CAST_INST
 #undef   LAST_CAST_INST
 
+#undef  FIRST_FUNCLETPAD_INST
+#undef HANDLE_FUNCLETPAD_INST
+#undef   LAST_FUNCLETPAD_INST
+
 #undef  FIRST_OTHER_INST
 #undef HANDLE_OTHER_INST
 #undef   LAST_OTHER_INST
 
 #ifdef HANDLE_INST
 #undef HANDLE_INST
 #endif

llvm/trunk/include/llvm/IR/Instructions.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_INSTRUCTIONS_H
 #define LLVM_IR_INSTRUCTIONS_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <iterator>

 template <>
 struct OperandTraits<ResumeInst> :
     public FixedNumOperandTraits<ResumeInst, 1> {
 };
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ResumeInst, Value)
 
 //===----------------------------------------------------------------------===//
-//                               CatchEndPadInst Class
+//                         CatchSwitchInst Class
 //===----------------------------------------------------------------------===//
+class CatchSwitchInst : public TerminatorInst {
+  void *operator new(size_t, unsigned) = delete;
+  /// ReservedSpace - The number of operands actually allocated.  NumOperands is
+  /// the number actually in use.
+  unsigned ReservedSpace;
+  // Operand[0] = Outer scope
+  // Operand[1] = Unwind block destination
+  // Operand[n] = BasicBlock to go to on match
+  CatchSwitchInst(const CatchSwitchInst &CSI);
+  void init(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumReserved);
+  void growOperands(unsigned Size);
+  // allocate space for exactly zero operands
+  void *operator new(size_t s) { return User::operator new(s); }
+  /// CatchSwitchInst ctor - Create a new switch instruction, specifying a
+  /// default destination.  The number of additional handlers can be specified
+  /// here to make memory allocation more efficient.
+  /// This constructor can also autoinsert before another instruction.
+  CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
+                  unsigned NumHandlers, const Twine &NameStr,
+                  Instruction *InsertBefore);
 
-class CatchEndPadInst : public TerminatorInst {
-private:
-  CatchEndPadInst(const CatchEndPadInst &RI);
-
-  void init(BasicBlock *UnwindBB);
-  CatchEndPadInst(LLVMContext &C, BasicBlock *UnwindBB, unsigned Values,
-                  Instruction *InsertBefore = nullptr);
-  CatchEndPadInst(LLVMContext &C, BasicBlock *UnwindBB, unsigned Values,
+  /// CatchSwitchInst ctor - Create a new switch instruction, specifying a
+  /// default destination.  The number of additional handlers can be specified
+  /// here to make memory allocation more efficient.
+  /// This constructor also autoinserts at the end of the specified BasicBlock.
+  CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
+                  unsigned NumHandlers, const Twine &NameStr,
                   BasicBlock *InsertAtEnd);
 
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
-  CatchEndPadInst *cloneImpl() const;
+  CatchSwitchInst *cloneImpl() const;
 
 public:
-  static CatchEndPadInst *Create(LLVMContext &C, BasicBlock *UnwindBB = nullptr,
+  static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest,
+                                 unsigned NumHandlers,
+                                 const Twine &NameStr = "",
                                  Instruction *InsertBefore = nullptr) {
-    unsigned Values = UnwindBB ? 1 : 0;
-    return new (Values) CatchEndPadInst(C, UnwindBB, Values, InsertBefore);
+    return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr,
+                               InsertBefore);
   }
-  static CatchEndPadInst *Create(LLVMContext &C, BasicBlock *UnwindBB,
+  static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest,
+                                 unsigned NumHandlers, const Twine &NameStr,
                                  BasicBlock *InsertAtEnd) {
-    unsigned Values = UnwindBB ? 1 : 0;
-    return new (Values) CatchEndPadInst(C, UnwindBB, Values, InsertAtEnd);
+    return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr,
+                               InsertAtEnd);
   }
 
   /// Provide fast operand accessors
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
+  // Accessor Methods for CatchSwitch stmt
+  Value *getParentPad() const { return getOperand(0); }
+  void setParentPad(Value *ParentPad) { setOperand(0, ParentPad); }
+
+  // Accessor Methods for CatchSwitch stmt
   bool hasUnwindDest() const { return getSubclassDataFromInstruction() & 1; }
   bool unwindsToCaller() const { return !hasUnwindDest(); }
-
-  /// Convenience accessor. Returns null if there is no return value.
-  unsigned getNumSuccessors() const { return hasUnwindDest() ? 1 : 0; }
-
   BasicBlock *getUnwindDest() const {
-    return hasUnwindDest() ? cast<BasicBlock>(Op<-1>()) : nullptr;
+    if (hasUnwindDest())
+      return cast<BasicBlock>(getOperand(1));
+    return nullptr;
   }
-  void setUnwindDest(BasicBlock *NewDest) {
-    assert(NewDest);
-    Op<-1>() = NewDest;
+  void setUnwindDest(BasicBlock *UnwindDest) {
+    assert(UnwindDest);
+    assert(hasUnwindDest());
+    setOperand(1, UnwindDest);
   }
 
-  // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const Instruction *I) {
-    return (I->getOpcode() == Instruction::CatchEndPad);
-  }
-  static inline bool classof(const Value *V) {
-    return isa<Instruction>(V) && classof(cast<Instruction>(V));
+  /// getNumHandlers - return the number of 'handlers' in this catchswitch
+  /// instruction, except the default handler
+  unsigned getNumHandlers() const {
+    if (hasUnwindDest())
+      return getNumOperands() - 2;
+    return getNumOperands() - 1;
   }
 
 private:
-  BasicBlock *getSuccessorV(unsigned Idx) const override;
-  unsigned getNumSuccessorsV() const override;
-  void setSuccessorV(unsigned Idx, BasicBlock *B) override;
-
-  // Shadow Instruction::setInstructionSubclassData with a private forwarding
-  // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
+  static BasicBlock *handler_helper(Value *V) { return cast<BasicBlock>(V); }
+  static const BasicBlock *handler_helper(const Value *V) {
+    return cast<BasicBlock>(V);
   }
-};
-
-template <>
-struct OperandTraits<CatchEndPadInst>
-    : public VariadicOperandTraits<CatchEndPadInst> {};
-
-DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchEndPadInst, Value)
 
-//===----------------------------------------------------------------------===//
-//                           CatchPadInst Class
-//===----------------------------------------------------------------------===//
-
-class CatchPadInst : public TerminatorInst {
-private:
-  void init(BasicBlock *IfNormal, BasicBlock *IfException,
-            ArrayRef<Value *> Args, const Twine &NameStr);
-
-  CatchPadInst(const CatchPadInst &CPI);
+public:
+  typedef std::pointer_to_unary_function<Value *, BasicBlock *> DerefFnTy;
+  typedef mapped_iterator<op_iterator, DerefFnTy> handler_iterator;
+  typedef iterator_range<handler_iterator> handler_range;
 
-  explicit CatchPadInst(BasicBlock *IfNormal, BasicBlock *IfException,
-                        ArrayRef<Value *> Args, unsigned Values,
-                        const Twine &NameStr, Instruction *InsertBefore);
-  explicit CatchPadInst(BasicBlock *IfNormal, BasicBlock *IfException,
-                        ArrayRef<Value *> Args, unsigned Values,
-                        const Twine &NameStr, BasicBlock *InsertAtEnd);
 
-protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
-  friend class Instruction;
-  CatchPadInst *cloneImpl() const;
+  typedef std::pointer_to_unary_function<const Value *, const BasicBlock *>
+      ConstDerefFnTy;
+  typedef mapped_iterator<const_op_iterator, ConstDerefFnTy> const_handler_iterator;
+  typedef iterator_range<const_handler_iterator> const_handler_range;
 
-public:
-  static CatchPadInst *Create(BasicBlock *IfNormal, BasicBlock *IfException,
-                              ArrayRef<Value *> Args, const Twine &NameStr = "",
-                              Instruction *InsertBefore = nullptr) {
-    unsigned Values = unsigned(Args.size()) + 2;
-    return new (Values) CatchPadInst(IfNormal, IfException, Args, Values,
-                                     NameStr, InsertBefore);
+  /// Returns an iterator that points to the first handler in CatchSwitchInst.
+  handler_iterator handler_begin() {
+    op_iterator It = op_begin() + 1;
+    if (hasUnwindDest())
+      ++It;
+    return handler_iterator(It, DerefFnTy(handler_helper));
   }
-  static CatchPadInst *Create(BasicBlock *IfNormal, BasicBlock *IfException,
-                              ArrayRef<Value *> Args, const Twine &NameStr,
-                              BasicBlock *InsertAtEnd) {
-    unsigned Values = unsigned(Args.size()) + 2;
-    return new (Values)
-        CatchPadInst(IfNormal, IfException, Args, Values, NameStr, InsertAtEnd);
+  /// Returns an iterator that points to the first handler in the
+  /// CatchSwitchInst.
+  const_handler_iterator handler_begin() const {
+    const_op_iterator It = op_begin() + 1;
+    if (hasUnwindDest())
+      ++It;
+    return const_handler_iterator(It, ConstDerefFnTy(handler_helper));
   }
 
-  /// Provide fast operand accessors
-  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
-
-  /// getNumArgOperands - Return the number of catchpad arguments.
-  ///
-  unsigned getNumArgOperands() const { return getNumOperands() - 2; }
-
-  /// getArgOperand/setArgOperand - Return/set the i-th catchpad argument.
-  ///
-  Value *getArgOperand(unsigned i) const { return getOperand(i); }
-  void setArgOperand(unsigned i, Value *v) { setOperand(i, v); }
-
-  /// arg_operands - iteration adapter for range-for loops.
-  iterator_range<op_iterator> arg_operands() {
-    return make_range(op_begin(), op_end() - 2);
+  /// Returns a read-only iterator that points one past the last
+  /// handler in the CatchSwitchInst.
+  handler_iterator handler_end() {
+    return handler_iterator(op_end(), DerefFnTy(handler_helper));
   }
-
-  /// arg_operands - iteration adapter for range-for loops.
-  iterator_range<const_op_iterator> arg_operands() const {
-    return make_range(op_begin(), op_end() - 2);
+  /// Returns an iterator that points one past the last handler in the
+  /// CatchSwitchInst.
+  const_handler_iterator handler_end() const {
+    return const_handler_iterator(op_end(), ConstDerefFnTy(handler_helper));
   }
 
-  /// \brief Wrappers for getting the \c Use of a catchpad argument.
-  const Use &getArgOperandUse(unsigned i) const { return getOperandUse(i); }
-  Use &getArgOperandUse(unsigned i) { return getOperandUse(i); }
-
-  // get*Dest - Return the destination basic blocks...
-  BasicBlock *getNormalDest() const { return cast<BasicBlock>(Op<-2>()); }
-  BasicBlock *getUnwindDest() const { return cast<BasicBlock>(Op<-1>()); }
-  void setNormalDest(BasicBlock *B) { Op<-2>() = B; }
-  void setUnwindDest(BasicBlock *B) { Op<-1>() = B; }
-
-  BasicBlock *getSuccessor(unsigned i) const {
-    assert(i < 2 && "Successor # out of range for catchpad!");
-    return i == 0 ? getNormalDest() : getUnwindDest();
+  /// handlers - iteration adapter for range-for loops.
+  handler_range handlers() {
+    return make_range(handler_begin(), handler_end());
   }
 
-  void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
-    assert(idx < 2 && "Successor # out of range for catchpad!");
-    *(&Op<-2>() + idx) = NewSucc;
+  /// handlers - iteration adapter for range-for loops.
+  const_handler_range handlers() const {
+    return make_range(handler_begin(), handler_end());
   }
 
-  unsigned getNumSuccessors() const { return 2; }
+  /// addHandler - Add an entry to the switch instruction...
+  /// Note:
+  /// This action invalidates handler_end(). Old handler_end() iterator will
+  /// point to the added handler.
+  void addHandler(BasicBlock *Dest);
+
+  unsigned getNumSuccessors() const { return getNumOperands() - 1; }
+  BasicBlock *getSuccessor(unsigned Idx) const {
+    assert(Idx < getNumSuccessors() &&
+           "Successor # out of range for catchswitch!");
+    return cast<BasicBlock>(getOperand(Idx + 1));
+  }
+  void setSuccessor(unsigned Idx, BasicBlock *NewSucc) {
+    assert(Idx < getNumSuccessors() &&
+           "Successor # out of range for catchswitch!");
+    setOperand(Idx + 1, NewSucc);
+  }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Instruction *I) {
-    return I->getOpcode() == Instruction::CatchPad;
+    return I->getOpcode() == Instruction::CatchSwitch;
   }
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
 private:
-  BasicBlock *getSuccessorV(unsigned idx) const override;
+  BasicBlock *getSuccessorV(unsigned Idx) const override;
   unsigned getNumSuccessorsV() const override;
-  void setSuccessorV(unsigned idx, BasicBlock *B) override;
+  void setSuccessorV(unsigned Idx, BasicBlock *B) override;
 };
 
 template <>
-struct OperandTraits<CatchPadInst>
-    : public VariadicOperandTraits<CatchPadInst, /*MINARITY=*/2> {};
+struct OperandTraits<CatchSwitchInst> : public HungoffOperandTraits<2> {};
 
-DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchPadInst, Value)
+DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchSwitchInst, Value)
 
 //===----------------------------------------------------------------------===//
 //                           TerminatePadInst Class
 //===----------------------------------------------------------------------===//
 
 class TerminatePadInst : public TerminatorInst {
 private:
-  void init(BasicBlock *BB, ArrayRef<Value *> Args);
+  void init(Value *ParentPad, BasicBlock *BB, ArrayRef<Value *> Args);
 
   TerminatePadInst(const TerminatePadInst &TPI);
 
-  explicit TerminatePadInst(LLVMContext &C, BasicBlock *BB,
+  explicit TerminatePadInst(Value *ParentPad, BasicBlock *BB,
                             ArrayRef<Value *> Args, unsigned Values,
                             Instruction *InsertBefore);
-  explicit TerminatePadInst(LLVMContext &C, BasicBlock *BB,
+  explicit TerminatePadInst(Value *ParentPad, BasicBlock *BB,
                             ArrayRef<Value *> Args, unsigned Values,
                             BasicBlock *InsertAtEnd);
 
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
   TerminatePadInst *cloneImpl() const;
 
 public:
-  static TerminatePadInst *Create(LLVMContext &C, BasicBlock *BB = nullptr,
+  static TerminatePadInst *Create(Value *ParentPad, BasicBlock *BB = nullptr,
                                   ArrayRef<Value *> Args = None,
                                   Instruction *InsertBefore = nullptr) {
-    unsigned Values = unsigned(Args.size());
+    unsigned Values = unsigned(Args.size()) + 1;
     if (BB)
       ++Values;
-    return new (Values) TerminatePadInst(C, BB, Args, Values, InsertBefore);
+    return new (Values)
+        TerminatePadInst(ParentPad, BB, Args, Values, InsertBefore);
   }
-  static TerminatePadInst *Create(LLVMContext &C, BasicBlock *BB,
+  static TerminatePadInst *Create(Value *ParentPad, BasicBlock *BB,
                                   ArrayRef<Value *> Args,
                                   BasicBlock *InsertAtEnd) {
-    unsigned Values = unsigned(Args.size());
+    unsigned Values = unsigned(Args.size()) + 1;
     if (BB)
       ++Values;
-    return new (Values) TerminatePadInst(C, BB, Args, Values, InsertAtEnd);
+    return new (Values)
+        TerminatePadInst(ParentPad, BB, Args, Values, InsertAtEnd);
   }
 
   /// Provide fast operand accessors
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   bool hasUnwindDest() const { return getSubclassDataFromInstruction() & 1; }
   bool unwindsToCaller() const { return !hasUnwindDest(); }
 
   /// getNumArgOperands - Return the number of terminatepad arguments.
   ///
   unsigned getNumArgOperands() const {
     unsigned NumOperands = getNumOperands();
     if (hasUnwindDest())
-      return NumOperands - 1;
-    return NumOperands;
+      return NumOperands - 2;
+  }
+
+  /// Convenience accessors
+  Value *getParentPad() const { return Op<-1>(); }
+  void setParentPad(Value *ParentPad) {
+    assert(ParentPad);
+    Op<-1>() = ParentPad;
   }
 
   /// getArgOperand/setArgOperand - Return/set the i-th terminatepad argument.
   ///
   Value *getArgOperand(unsigned i) const { return getOperand(i); }
   void setArgOperand(unsigned i, Value *v) { setOperand(i, v); }
 
+  const_op_iterator arg_begin() const { return op_begin(); }
+  op_iterator arg_begin() { return op_begin(); }
+
   const_op_iterator arg_end() const {
     if (hasUnwindDest())
-      return op_end() - 1;
-    return op_end();
+      return op_end() - 2;
   }
 
   op_iterator arg_end() {
     if (hasUnwindDest())
-      return op_end() - 1;
-    return op_end();
+      return op_end() - 2;
   }
 
   /// arg_operands - iteration adapter for range-for loops.
   iterator_range<op_iterator> arg_operands() {
-    return make_range(op_begin(), arg_end());
+    return make_range(arg_begin(), arg_end());
   }
 
   /// arg_operands - iteration adapter for range-for loops.
   iterator_range<const_op_iterator> arg_operands() const {
-    return make_range(op_begin(), arg_end());
+    return make_range(arg_begin(), arg_end());
   }
 
   /// \brief Wrappers for getting the \c Use of a terminatepad argument.
   const Use &getArgOperandUse(unsigned i) const { return getOperandUse(i); }
   Use &getArgOperandUse(unsigned i) { return getOperandUse(i); }
 
   // get*Dest - Return the destination basic blocks...
   BasicBlock *getUnwindDest() const {
     if (!hasUnwindDest())
       return nullptr;
-    return cast<BasicBlock>(Op<-1>());
+    return cast<BasicBlock>(Op<-2>());
   }
   void setUnwindDest(BasicBlock *B) {
     assert(B && hasUnwindDest());
-    Op<-1>() = B;
+    Op<-2>() = B;
   }
 
   unsigned getNumSuccessors() const { return hasUnwindDest() ? 1 : 0; }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::TerminatePad;
   }

 
 template <>
 struct OperandTraits<TerminatePadInst>
     : public VariadicOperandTraits<TerminatePadInst, /*MINARITY=*/1> {};
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(TerminatePadInst, Value)
 
 //===----------------------------------------------------------------------===//
-//                           CleanupPadInst Class
+//                               CleanupPadInst Class
 //===----------------------------------------------------------------------===//
-
-class CleanupPadInst : public Instruction {
+class CleanupPadInst : public FuncletPadInst {
 private:
-  void init(ArrayRef<Value *> Args, const Twine &NameStr);
+  explicit CleanupPadInst(Value *ParentPad, ArrayRef<Value *> Args,
+                          unsigned Values, const Twine &NameStr,
+                          Instruction *InsertBefore)
+      : FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values,
+                       NameStr, InsertBefore) {}
+  explicit CleanupPadInst(Value *ParentPad, ArrayRef<Value *> Args,
+                          unsigned Values, const Twine &NameStr,
+                          BasicBlock *InsertAtEnd)
+      : FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values,
+                       NameStr, InsertAtEnd) {}
 
-  CleanupPadInst(const CleanupPadInst &CPI);
+public:
+  static CleanupPadInst *Create(Value *ParentPad, ArrayRef<Value *> Args = None,
+                                const Twine &NameStr = "",
+                                Instruction *InsertBefore = nullptr) {
+    unsigned Values = 1 + Args.size();
+    return new (Values)
+        CleanupPadInst(ParentPad, Args, Values, NameStr, InsertBefore);
+  }
+  static CleanupPadInst *Create(Value *ParentPad, ArrayRef<Value *> Args,
+                                const Twine &NameStr, BasicBlock *InsertAtEnd) {
+    unsigned Values = 1 + Args.size();
+    return new (Values)
+        CleanupPadInst(ParentPad, Args, Values, NameStr, InsertAtEnd);
+  }
 
-  explicit CleanupPadInst(LLVMContext &C, ArrayRef<Value *> Args,
-                          const Twine &NameStr, Instruction *InsertBefore);
-  explicit CleanupPadInst(LLVMContext &C, ArrayRef<Value *> Args,
-                          const Twine &NameStr, BasicBlock *InsertAtEnd);
+  /// \brief Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const Instruction *I) {
+    return I->getOpcode() == Instruction::CleanupPad;
+  }
+  static inline bool classof(const Value *V) {
+    return isa<Instruction>(V) && classof(cast<Instruction>(V));
+  }
+};
 
-protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
-  friend class Instruction;
-  CleanupPadInst *cloneImpl() const;
+//===----------------------------------------------------------------------===//
+//                               CatchPadInst Class
+//===----------------------------------------------------------------------===//
+class CatchPadInst : public FuncletPadInst {
+private:
+  explicit CatchPadInst(Value *CatchSwitch, ArrayRef<Value *> Args,
+                        unsigned Values, const Twine &NameStr,
+                        Instruction *InsertBefore)
+      : FuncletPadInst(Instruction::CatchPad, CatchSwitch, Args, Values,
+                       NameStr, InsertBefore) {}
+  explicit CatchPadInst(Value *CatchSwitch, ArrayRef<Value *> Args,
+                        unsigned Values, const Twine &NameStr,
+                        BasicBlock *InsertAtEnd)
+      : FuncletPadInst(Instruction::CatchPad, CatchSwitch, Args, Values,
+                       NameStr, InsertAtEnd) {}
 
 public:
-  static CleanupPadInst *Create(LLVMContext &C, ArrayRef<Value *> Args,
-                                const Twine &NameStr = "",
-                                Instruction *InsertBefore = nullptr) {
-    return new (Args.size()) CleanupPadInst(C, Args, NameStr, InsertBefore);
+  static CatchPadInst *Create(Value *CatchSwitch, ArrayRef<Value *> Args,
+    unsigned Values = 1 + Args.size();
+    return new (Values)
+        CatchPadInst(CatchSwitch, Args, Values, NameStr, InsertBefore);
   }
-  static CleanupPadInst *Create(LLVMContext &C, ArrayRef<Value *> Args,
-                                const Twine &NameStr, BasicBlock *InsertAtEnd) {
-    return new (Args.size()) CleanupPadInst(C, Args, NameStr, InsertAtEnd);
+  static CatchPadInst *Create(Value *CatchSwitch, ArrayRef<Value *> Args,
+    unsigned Values = 1 + Args.size();
+    return new (Values)
+        CatchPadInst(CatchSwitch, Args, Values, NameStr, InsertAtEnd);
   }
 
-  /// Provide fast operand accessors
-  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
+  /// Convenience accessors
+  CatchSwitchInst *getCatchSwitch() const {
+    return cast<CatchSwitchInst>(Op<-1>());
+  }
+  void setCatchSwitch(Value *CatchSwitch) {
+    assert(CatchSwitch);
+    Op<-1>() = CatchSwitch;
+  }
 
-  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  /// \brief Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Instruction *I) {
-    return I->getOpcode() == Instruction::CleanupPad;
+    return I->getOpcode() == Instruction::CatchPad;
   }
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
 
-template <>
-struct OperandTraits<CleanupPadInst>
-    : public VariadicOperandTraits<CleanupPadInst, /*MINARITY=*/0> {};
-
-DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CleanupPadInst, Value)
-
 //===----------------------------------------------------------------------===//
 //                               CatchReturnInst Class
 //===----------------------------------------------------------------------===//
 
 class CatchReturnInst : public TerminatorInst {
   CatchReturnInst(const CatchReturnInst &RI);
 
-  void init(CatchPadInst *CatchPad, BasicBlock *BB);
-  CatchReturnInst(CatchPadInst *CatchPad, BasicBlock *BB,
-                  Instruction *InsertBefore);
-  CatchReturnInst(CatchPadInst *CatchPad, BasicBlock *BB,
-                  BasicBlock *InsertAtEnd);
+  void init(Value *CatchPad, BasicBlock *BB);
+  CatchReturnInst(Value *CatchPad, BasicBlock *BB, Instruction *InsertBefore);
+  CatchReturnInst(Value *CatchPad, BasicBlock *BB, BasicBlock *InsertAtEnd);
 
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
   CatchReturnInst *cloneImpl() const;
 
 public:
-  static CatchReturnInst *Create(CatchPadInst *CatchPad, BasicBlock *BB,
+  static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB,
                                  Instruction *InsertBefore = nullptr) {
     assert(CatchPad);
     assert(BB);
     return new (2) CatchReturnInst(CatchPad, BB, InsertBefore);
   }
-  static CatchReturnInst *Create(CatchPadInst *CatchPad, BasicBlock *BB,
+  static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB,
                                  BasicBlock *InsertAtEnd) {
     assert(CatchPad);
     assert(BB);
     return new (2) CatchReturnInst(CatchPad, BB, InsertAtEnd);
   }
 
   /// Provide fast operand accessors
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   /// Convenience accessors.
   CatchPadInst *getCatchPad() const { return cast<CatchPadInst>(Op<0>()); }
   void setCatchPad(CatchPadInst *CatchPad) {
     assert(CatchPad);
     Op<0>() = CatchPad;
   }
 
   BasicBlock *getSuccessor() const { return cast<BasicBlock>(Op<1>()); }
   void setSuccessor(BasicBlock *NewSucc) {
     assert(NewSucc);
     Op<1>() = NewSucc;
   }
   unsigned getNumSuccessors() const { return 1; }
 
+  Value *getParentPad() const {
+    return getCatchPad()->getCatchSwitch()->getParentPad();
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Instruction *I) {
     return (I->getOpcode() == Instruction::CatchRet);
   }
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
 private:
   BasicBlock *getSuccessorV(unsigned Idx) const override;
   unsigned getNumSuccessorsV() const override;
   void setSuccessorV(unsigned Idx, BasicBlock *B) override;
 };
 
 template <>
 struct OperandTraits<CatchReturnInst>
     : public FixedNumOperandTraits<CatchReturnInst, 2> {};
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchReturnInst, Value)
 
 //===----------------------------------------------------------------------===//
-//                               CleanupEndPadInst Class
-//===----------------------------------------------------------------------===//
-
-class CleanupEndPadInst : public TerminatorInst {
-private:
-  CleanupEndPadInst(const CleanupEndPadInst &CEPI);
-
-  void init(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB);
-  CleanupEndPadInst(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB,
-                    unsigned Values, Instruction *InsertBefore = nullptr);
-  CleanupEndPadInst(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB,
-                    unsigned Values, BasicBlock *InsertAtEnd);
-
-protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
-  friend class Instruction;
-  CleanupEndPadInst *cloneImpl() const;
-
-public:
-  static CleanupEndPadInst *Create(CleanupPadInst *CleanupPad,
-                                   BasicBlock *UnwindBB = nullptr,
-                                   Instruction *InsertBefore = nullptr) {
-    unsigned Values = UnwindBB ? 2 : 1;
-    return new (Values)
-        CleanupEndPadInst(CleanupPad, UnwindBB, Values, InsertBefore);
-  }
-  static CleanupEndPadInst *Create(CleanupPadInst *CleanupPad,
-                                   BasicBlock *UnwindBB,
-                                   BasicBlock *InsertAtEnd) {
-    unsigned Values = UnwindBB ? 2 : 1;
-    return new (Values)
-        CleanupEndPadInst(CleanupPad, UnwindBB, Values, InsertAtEnd);
-  }
-
-  /// Provide fast operand accessors
-  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
-
-  bool hasUnwindDest() const { return getSubclassDataFromInstruction() & 1; }
-  bool unwindsToCaller() const { return !hasUnwindDest(); }
-
-  unsigned getNumSuccessors() const { return hasUnwindDest() ? 1 : 0; }
-
-  /// Convenience accessors
-  CleanupPadInst *getCleanupPad() const {
-    return cast<CleanupPadInst>(Op<-1>());
-  }
-  void setCleanupPad(CleanupPadInst *CleanupPad) {
-    assert(CleanupPad);
-    Op<-1>() = CleanupPad;
-  }
-
-  BasicBlock *getUnwindDest() const {
-    return hasUnwindDest() ? cast<BasicBlock>(Op<-2>()) : nullptr;
-  }
-  void setUnwindDest(BasicBlock *NewDest) {
-    assert(hasUnwindDest());
-    assert(NewDest);
-    Op<-2>() = NewDest;
-  }
-
-  // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const Instruction *I) {
-    return (I->getOpcode() == Instruction::CleanupEndPad);
-  }
-  static inline bool classof(const Value *V) {
-    return isa<Instruction>(V) && classof(cast<Instruction>(V));
-  }
-
-private:
-  BasicBlock *getSuccessorV(unsigned Idx) const override;
-  unsigned getNumSuccessorsV() const override;
-  void setSuccessorV(unsigned Idx, BasicBlock *B) override;
-
-  // Shadow Instruction::setInstructionSubclassData with a private forwarding
-  // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
-  }
-};
-
-template <>
-struct OperandTraits<CleanupEndPadInst>
-    : public VariadicOperandTraits<CleanupEndPadInst, /*MINARITY=*/1> {};
-
-DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CleanupEndPadInst, Value)
-
-//===----------------------------------------------------------------------===//
 //                               CleanupReturnInst Class
 //===----------------------------------------------------------------------===//
 
 class CleanupReturnInst : public TerminatorInst {
 private:
   CleanupReturnInst(const CleanupReturnInst &RI);
 
-  void init(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB);
-  CleanupReturnInst(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB,
-                    unsigned Values, Instruction *InsertBefore = nullptr);
-  CleanupReturnInst(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB,
-                    unsigned Values, BasicBlock *InsertAtEnd);
+  void init(Value *CleanupPad, BasicBlock *UnwindBB);
+  CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
+                    Instruction *InsertBefore = nullptr);
+  CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
+                    BasicBlock *InsertAtEnd);
 
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
   CleanupReturnInst *cloneImpl() const;
 
 public:
-  static CleanupReturnInst *Create(CleanupPadInst *CleanupPad,
+  static CleanupReturnInst *Create(Value *CleanupPad,
                                    BasicBlock *UnwindBB = nullptr,
                                    Instruction *InsertBefore = nullptr) {
     assert(CleanupPad);
     unsigned Values = 1;
     if (UnwindBB)
       ++Values;
     return new (Values)
         CleanupReturnInst(CleanupPad, UnwindBB, Values, InsertBefore);
   }
-  static CleanupReturnInst *Create(CleanupPadInst *CleanupPad,
-                                   BasicBlock *UnwindBB,
+  static CleanupReturnInst *Create(Value *CleanupPad, BasicBlock *UnwindBB,
                                    BasicBlock *InsertAtEnd) {
     assert(CleanupPad);
     unsigned Values = 1;
     if (UnwindBB)
       ++Values;
     return new (Values)
         CleanupReturnInst(CleanupPad, UnwindBB, Values, InsertAtEnd);
   }
 
   /// Provide fast operand accessors
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   bool hasUnwindDest() const { return getSubclassDataFromInstruction() & 1; }
   bool unwindsToCaller() const { return !hasUnwindDest(); }
 
   /// Convenience accessor.
   CleanupPadInst *getCleanupPad() const {
-    return cast<CleanupPadInst>(Op<-1>());
+    return cast<CleanupPadInst>(Op<0>());
   }
   void setCleanupPad(CleanupPadInst *CleanupPad) {
     assert(CleanupPad);
-    Op<-1>() = CleanupPad;
+    Op<0>() = CleanupPad;
   }
 
   unsigned getNumSuccessors() const { return hasUnwindDest() ? 1 : 0; }
 
   BasicBlock *getUnwindDest() const {
-    return hasUnwindDest() ? cast<BasicBlock>(Op<-2>()) : nullptr;
+    return hasUnwindDest() ? cast<BasicBlock>(Op<1>()) : nullptr;
   }
   void setUnwindDest(BasicBlock *NewDest) {
     assert(NewDest);
     assert(hasUnwindDest());
-    Op<-2>() = NewDest;
+    Op<1>() = NewDest;
   }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Instruction *I) {
     return (I->getOpcode() == Instruction::CleanupRet);
   }
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));

llvm/trunk/include/llvm/Transforms/Utils/Local.h

 /// is replaced with a new value. If Deref is true, an additional DW_OP_deref is
 /// prepended to the expression. If Offset is non-zero, a constant displacement
 /// is added to the expression (after the optional Deref). Offset can be
 /// negative. New llvm.dbg.declare is inserted immediately before AI.
 bool replaceDbgDeclareForAlloca(AllocaInst *AI, Value *NewAllocaAddress,
                                 DIBuilder &Builder, bool Deref, int Offset = 0);
 
 /// Replace 'BB's terminator with one that does not have an unwind successor
-/// block.  Rewrites `invoke` to `call`, `catchendpad unwind label %foo` to
-/// `catchendpad unwind to caller`, etc.  Updates any PHIs in unwind successor.
+/// block.  Rewrites `invoke` to `call`, `terminatepad unwind label %foo` to
+/// `terminatepad unwind to caller`, etc.  Updates any PHIs in unwind successor.
 ///
 /// \param BB  Block whose terminator will be replaced.  Its terminator must
 ///            have an unwind successor.
 void removeUnwindEdge(BasicBlock *BB);
 
 /// \brief Remove all blocks that can not be reached from the function's entry.
 ///
 /// Returns true if any basic block was removed.

llvm/trunk/lib/Analysis/CaptureTracking.cpp

bool isSafeToPrune(Instruction *I) {
 
       // Compute the case where both instructions are inside the same basic
       // block. Since instructions in the same BB as BeforeHere are numbered in
       // 'OrderedBB', avoid using 'dominates' and 'isPotentiallyReachable'
       // which are very expensive for large basic blocks.
       if (BB == BeforeHere->getParent()) {
         // 'I' dominates 'BeforeHere' => not safe to prune.
         //
-        // The value defined by an invoke/catchpad dominates an instruction only
+        // The value defined by an invoke dominates an instruction only
         // if it dominates every instruction in UseBB. A PHI is dominated only
         // if the instruction dominates every possible use in the UseBB. Since
         // UseBB == BB, avoid pruning.
-        if (isa<InvokeInst>(BeforeHere) || isa<CatchPadInst>(BeforeHere) ||
-            isa<PHINode>(I) || I == BeforeHere)
+        if (isa<InvokeInst>(BeforeHere) || isa<PHINode>(I) || I == BeforeHere)
           return false;
         if (!OrderedBB->dominates(BeforeHere, I))
           return false;
 
         // 'BeforeHere' comes before 'I', it's safe to prune if we also
         // guarantee that 'I' never reaches 'BeforeHere' through a back-edge or
         // by its successors, i.e, prune if:
         //

llvm/trunk/lib/Analysis/EHPersonalities.cpp

 //===- EHPersonalities.cpp - Compute EH-related information ---------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/IR/CFG.h"
+#include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/Support/Debug.h"
 using namespace llvm;
 
 /// See if the given exception handling personality function is one that we
 /// understand.  If so, return a description of it; otherwise return Unknown.
 EHPersonality llvm::classifyEHPersonality(const Value *Pers) {
   const Function *F =
       Pers ? dyn_cast<Function>(Pers->stripPointerCasts()) : nullptr;
   if (!F)

 
 bool llvm::canSimplifyInvokeNoUnwind(const Function *F) {
   EHPersonality Personality = classifyEHPersonality(F->getPersonalityFn());
   // We can't simplify any invokes to nounwind functions if the personality
   // function wants to catch asynch exceptions.  The nounwind attribute only
   // implies that the function does not throw synchronous exceptions.
   return !isAsynchronousEHPersonality(Personality);
 }
+
+DenseMap<BasicBlock *, ColorVector> llvm::colorEHFunclets(Function &F) {
+  SmallVector<std::pair<BasicBlock *, BasicBlock *>, 16> Worklist;
+  BasicBlock *EntryBlock = &F.getEntryBlock();
+  DenseMap<BasicBlock *, ColorVector> BlockColors;
+
+  // Build up the color map, which maps each block to its set of 'colors'.
+  // For any block B the "colors" of B are the set of funclets F (possibly
+  // including a root "funclet" representing the main function) such that
+  // F will need to directly contain B or a copy of B (where the term "directly
+  // contain" is used to distinguish from being "transitively contained" in
+  // a nested funclet).
+  //
+  // Note: Despite not being funclets in the truest sense, terminatepad and
+  // catchswitch are considered to belong to their own funclet for the purposes
+  // of coloring.
+
+  DEBUG_WITH_TYPE("winehprepare-coloring", dbgs() << "\nColoring funclets for "
+                                                  << F.getName() << "\n");
+
+  Worklist.push_back({EntryBlock, EntryBlock});
+
+  while (!Worklist.empty()) {
+    BasicBlock *Visiting;
+    BasicBlock *Color;
+    std::tie(Visiting, Color) = Worklist.pop_back_val();
+    DEBUG_WITH_TYPE("winehprepare-coloring",
+                    dbgs() << "Visiting " << Visiting->getName() << ", "
+                           << Color->getName() << "\n");
+    Instruction *VisitingHead = Visiting->getFirstNonPHI();
+    if (VisitingHead->isEHPad()) {
+      // Mark this funclet head as a member of itself.
+      Color = Visiting;
+    }
+    // Note that this is a member of the given color.
+    ColorVector &Colors = BlockColors[Visiting];
+    if (std::find(Colors.begin(), Colors.end(), Color) == Colors.end())
+      Colors.push_back(Color);
+    else
+      continue;
+
+    DEBUG_WITH_TYPE("winehprepare-coloring",
+                    dbgs() << "  Assigned color \'" << Color->getName()
+                           << "\' to block \'" << Visiting->getName()
+                           << "\'.\n");
+
+    BasicBlock *SuccColor = Color;
+    TerminatorInst *Terminator = Visiting->getTerminator();
+    if (auto *CatchRet = dyn_cast<CatchReturnInst>(Terminator)) {
+      Value *ParentPad = CatchRet->getParentPad();
+      if (isa<ConstantTokenNone>(ParentPad))
+        SuccColor = EntryBlock;
+      else
+        SuccColor = cast<Instruction>(ParentPad)->getParent();
+    }
+
+    for (BasicBlock *Succ : successors(Visiting))
+      Worklist.push_back({Succ, SuccColor});
+  }
+  return BlockColors;
+}

llvm/trunk/lib/Analysis/InstructionSimplify.cpp

static bool ValueDominatesPHI(Value *V, PHINode *P, const DominatorTree *DT) {
   if (DT) {
     if (!DT->isReachableFromEntry(P->getParent()))
       return true;
     if (!DT->isReachableFromEntry(I->getParent()))
       return false;
     return DT->dominates(I, P);
   }
 
-  // Otherwise, if the instruction is in the entry block, and is not an invoke,
-  // and is not a catchpad, then it obviously dominates all phi nodes.
+  // Otherwise, if the instruction is in the entry block and is not an invoke,
+  // then it obviously dominates all phi nodes.
   if (I->getParent() == &I->getParent()->getParent()->getEntryBlock() &&
-      !isa<InvokeInst>(I) && !isa<CatchPadInst>(I))
+      !isa<InvokeInst>(I))
     return true;
 
   return false;
 }
 
 /// ExpandBinOp - Simplify "A op (B op' C)" by distributing op over op', turning
 /// it into "(A op B) op' (A op C)".  Here "op" is given by Opcode and "op'" is
 /// given by OpcodeToExpand, while "A" corresponds to LHS and "B op' C" to RHS.

llvm/trunk/lib/Analysis/LoopInfo.cpp

 /// Routines that reform the loop CFG and split edges often fail on indirectbr.
 bool Loop::isSafeToClone() const {
   // Return false if any loop blocks contain indirectbrs, or there are any calls
   // to noduplicate functions.
   for (Loop::block_iterator I = block_begin(), E = block_end(); I != E; ++I) {
     if (isa<IndirectBrInst>((*I)->getTerminator()))
       return false;
 
-    if (const InvokeInst *II = dyn_cast<InvokeInst>((*I)->getTerminator()))
+    if (const InvokeInst *II = dyn_cast<InvokeInst>((*I)->getTerminator())) {
       if (II->cannotDuplicate())
         return false;
+      // Return false if any loop blocks contain invokes to EH-pads other than
+      // landingpads;  we don't know how to split those edges yet.
+      auto *FirstNonPHI = II->getUnwindDest()->getFirstNonPHI();
+      if (FirstNonPHI->isEHPad() && !isa<LandingPadInst>(FirstNonPHI))
+        return false;
+    }
 
     for (BasicBlock::iterator BI = (*I)->begin(), BE = (*I)->end(); BI != BE; ++BI) {
       if (const CallInst *CI = dyn_cast<CallInst>(BI)) {
         if (CI->cannotDuplicate())
           return false;
       }
       if (BI->getType()->isTokenTy() && BI->isUsedOutsideOfBlock(*I))
         return false;

llvm/trunk/lib/Analysis/ScalarEvolutionExpander.cpp

Value *SCEVExpander::ReuseOrCreateCast(Value *V, Type *Ty,
   return Ret;
 }
 
 static BasicBlock::iterator findInsertPointAfter(Instruction *I,
                                                  BasicBlock *MustDominate) {
   BasicBlock::iterator IP = ++I->getIterator();
   if (auto *II = dyn_cast<InvokeInst>(I))
     IP = II->getNormalDest()->begin();
-  if (auto *CPI = dyn_cast<CatchPadInst>(I))
-    IP = CPI->getNormalDest()->begin();
 
   while (isa<PHINode>(IP))
     ++IP;
 
   while (IP->isEHPad()) {
-    if (isa<LandingPadInst>(IP) || isa<CleanupPadInst>(IP)) {
+    if (isa<FuncletPadInst>(IP) || isa<LandingPadInst>(IP)) {
       ++IP;
     } else if (auto *TPI = dyn_cast<TerminatePadInst>(IP)) {
       IP = TPI->getUnwindDest()->getFirstNonPHI()->getIterator();
-    } else if (auto *CEPI = dyn_cast<CatchEndPadInst>(IP)) {
-      IP = CEPI->getUnwindDest()->getFirstNonPHI()->getIterator();
-    } else if (auto *CEPI = dyn_cast<CleanupEndPadInst>(IP)) {
-      IP = CEPI->getUnwindDest()->getFirstNonPHI()->getIterator();
-    } else if (isa<CatchPadInst>(IP)) {
+    } else if (isa<CatchSwitchInst>(IP)) {
       IP = MustDominate->getFirstInsertionPt();
     } else {
       llvm_unreachable("unexpected eh pad!");
     }
   }
 
   return IP;
 }

llvm/trunk/lib/Analysis/ValueTracking.cpp

bool llvm::isSafeToSpeculativelyExecute(const Value *V,
   case Instruction::IndirectBr:
   case Instruction::Switch:
   case Instruction::Unreachable:
   case Instruction::Fence:
   case Instruction::AtomicRMW:
   case Instruction::AtomicCmpXchg:
   case Instruction::LandingPad:
   case Instruction::Resume:
+  case Instruction::CatchSwitch:
   case Instruction::CatchPad:
-  case Instruction::CatchEndPad:
   case Instruction::CatchRet:
   case Instruction::CleanupPad:
-  case Instruction::CleanupEndPad:
   case Instruction::CleanupRet:
   case Instruction::TerminatePad:
     return false; // Misc instructions which have effects
   }
 }
 
 bool llvm::mayBeMemoryDependent(const Instruction &I) {
   return I.mayReadOrWriteMemory() || !isSafeToSpeculativelyExecute(&I);

llvm/trunk/lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(initialexec);
   KEYWORD(localexec);
   KEYWORD(zeroinitializer);
   KEYWORD(undef);
   KEYWORD(null);
   KEYWORD(none);
   KEYWORD(to);
   KEYWORD(caller);
+  KEYWORD(within);
+  KEYWORD(from);
   KEYWORD(tail);
   KEYWORD(musttail);
   KEYWORD(notail);
   KEYWORD(target);
   KEYWORD(triple);
   KEYWORD(unwind);
   KEYWORD(deplibs);             // FIXME: Remove in 4.0.
   KEYWORD(datalayout);
#define INSTKEYWORD(STR, Enum)                                                 \
   INSTKEYWORD(extractelement, ExtractElement);
   INSTKEYWORD(insertelement,  InsertElement);
   INSTKEYWORD(shufflevector,  ShuffleVector);
   INSTKEYWORD(extractvalue,   ExtractValue);
   INSTKEYWORD(insertvalue,    InsertValue);
   INSTKEYWORD(landingpad,     LandingPad);
   INSTKEYWORD(cleanupret,     CleanupRet);
   INSTKEYWORD(catchret,       CatchRet);
+  INSTKEYWORD(catchswitch,  CatchSwitch);
   INSTKEYWORD(catchpad,     CatchPad);
   INSTKEYWORD(terminatepad, TerminatePad);
   INSTKEYWORD(cleanuppad,   CleanupPad);
-  INSTKEYWORD(catchendpad,  CatchEndPad);
-  INSTKEYWORD(cleanupendpad, CleanupEndPad);
 #undef INSTKEYWORD
 
 #define DWKEYWORD(TYPE, TOKEN)                                                 \
   do {                                                                         \
     if (Keyword.startswith("DW_" #TYPE "_")) {                                 \
       StrVal.assign(Keyword.begin(), Keyword.end());                           \
       return lltok::TOKEN;                                                     \
     }                                                                          \

llvm/trunk/lib/AsmParser/LLParser.h

private:
     // lists. This means that RAUW doesn't work, even on temporary MDNodes
     // which otherwise support RAUW. Instead, we defer resolving MDNode
     // references until the definitions have been processed.
     struct MDRef {
       SMLoc Loc;
       unsigned MDKind, MDSlot;
     };
 
-    /// Indicates which operator an operand allows (for the few operands that
-    /// may only reference a certain operator).
-    enum OperatorConstraint {
-      OC_None = 0,  // No constraint
-      OC_CatchPad,  // Must be CatchPadInst
-      OC_CleanupPad // Must be CleanupPadInst
-    };
-
     SmallVector<Instruction*, 64> InstsWithTBAATag;
 
     // Type resolution handling data structures.  The location is set when we
     // have processed a use of the type but not a definition yet.
     StringMap<std::pair<Type*, LocTy> > NamedTypes;
     std::map<unsigned, std::pair<Type*, LocTy> > NumberedTypes;
 
     std::map<unsigned, TrackingMDNodeRef> NumberedMetadata;
public:
 
       Function &getFunction() const { return F; }
 
       bool FinishFunction();
 
       /// GetVal - Get a value with the specified name or ID, creating a
       /// forward reference record if needed.  This can return null if the value
       /// exists but does not have the right type.
-      Value *GetVal(const std::string &Name, Type *Ty, LocTy Loc,
-                    OperatorConstraint OC = OC_None);
-      Value *GetVal(unsigned ID, Type *Ty, LocTy Loc,
-                    OperatorConstraint OC = OC_None);
+      Value *GetVal(const std::string &Name, Type *Ty, LocTy Loc);
+      Value *GetVal(unsigned ID, Type *Ty, LocTy Loc);
 
       /// SetInstName - After an instruction is parsed and inserted into its
       /// basic block, this installs its name.
       bool SetInstName(int NameID, const std::string &NameStr, LocTy NameLoc,
                        Instruction *Inst);
 
       /// GetBB - Get a basic block with the specified name or ID, creating a
       /// forward reference record if needed.  This can return null if the value
       /// is not a BasicBlock.
       BasicBlock *GetBB(const std::string &Name, LocTy Loc);
       BasicBlock *GetBB(unsigned ID, LocTy Loc);
 
       /// DefineBB - Define the specified basic block, which is either named or
       /// unnamed.  If there is an error, this returns null otherwise it returns
       /// the block being defined.
       BasicBlock *DefineBB(const std::string &Name, LocTy Loc);
 
       bool resolveForwardRefBlockAddresses();
     };
 
     bool ConvertValIDToValue(Type *Ty, ValID &ID, Value *&V,
-                             PerFunctionState *PFS,
-                             OperatorConstraint OC = OC_None);
+                             PerFunctionState *PFS);
 
     bool parseConstantValue(Type *Ty, Constant *&C);
-    bool ParseValue(Type *Ty, Value *&V, PerFunctionState *PFS,
-                    OperatorConstraint OC = OC_None);
-    bool ParseValue(Type *Ty, Value *&V, PerFunctionState &PFS,
-                    OperatorConstraint OC = OC_None) {
-      return ParseValue(Ty, V, &PFS, OC);
+    bool ParseValue(Type *Ty, Value *&V, PerFunctionState *PFS);
+    bool ParseValue(Type *Ty, Value *&V, PerFunctionState &PFS) {
+      return ParseValue(Ty, V, &PFS);
     }
+
     bool ParseValue(Type *Ty, Value *&V, LocTy &Loc,
                     PerFunctionState &PFS) {
       Loc = Lex.getLoc();
       return ParseValue(Ty, V, &PFS);
     }
 
     bool ParseTypeAndValue(Value *&V, PerFunctionState *PFS);
     bool ParseTypeAndValue(Value *&V, PerFunctionState &PFS) {
#include "llvm/IR/Metadata.def"
     bool ParseRet(Instruction *&Inst, BasicBlock *BB, PerFunctionState &PFS);
     bool ParseBr(Instruction *&Inst, PerFunctionState &PFS);
     bool ParseSwitch(Instruction *&Inst, PerFunctionState &PFS);
     bool ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS);
     bool ParseInvoke(Instruction *&Inst, PerFunctionState &PFS);
     bool ParseResume(Instruction *&Inst, PerFunctionState &PFS);
     bool ParseCleanupRet(Instruction *&Inst, PerFunctionState &PFS);
     bool ParseCatchRet(Instruction *&Inst, PerFunctionState &PFS);
+    bool ParseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS);
     bool ParseCatchPad(Instruction *&Inst, PerFunctionState &PFS);
     bool ParseTerminatePad(Instruction *&Inst, PerFunctionState &PFS);
     bool ParseCleanupPad(Instruction *&Inst, PerFunctionState &PFS);
-    bool ParseCatchEndPad(Instruction *&Inst, PerFunctionState &PFS);
-    bool ParseCleanupEndPad(Instruction *&Inst, PerFunctionState &PFS);
 
     bool ParseArithmetic(Instruction *&I, PerFunctionState &PFS, unsigned Opc,
                          unsigned OperandType);
     bool ParseLogical(Instruction *&I, PerFunctionState &PFS, unsigned Opc);
     bool ParseCompare(Instruction *&I, PerFunctionState &PFS, unsigned Opc);
     bool ParseCast(Instruction *&I, PerFunctionState &PFS, unsigned Opc);
     bool ParseSelect(Instruction *&I, PerFunctionState &PFS);
     bool ParseVA_Arg(Instruction *&I, PerFunctionState &PFS);

llvm/trunk/lib/AsmParser/LLParser.cpp

bool LLParser::PerFunctionState::FinishFunction() {
   return false;
 }
 
 
 /// GetVal - Get a value with the specified name or ID, creating a
 /// forward reference record if needed.  This can return null if the value
 /// exists but does not have the right type.
 Value *LLParser::PerFunctionState::GetVal(const std::string &Name, Type *Ty,
-                                          LocTy Loc, OperatorConstraint OC) {
+                                          LocTy Loc) {
   // Look this name up in the normal function symbol table.
   Value *Val = F.getValueSymbolTable().lookup(Name);
 
   // If this is a forward reference for the value, see if we already created a
   // forward ref record.
   if (!Val) {
     auto I = ForwardRefVals.find(Name);
     if (I != ForwardRefVals.end())
       Val = I->second.first;
   }
 
   // If we have the value in the symbol table or fwd-ref table, return it.
   if (Val) {
-    // Check operator constraints.
-    switch (OC) {
-    case OC_None:
-      // no constraint
-      break;
-    case OC_CatchPad:
-      if (!isa<CatchPadInst>(Val)) {
-        P.Error(Loc, "'%" + Name + "' is not a catchpad");
-        return nullptr;
-      }
-      break;
-    case OC_CleanupPad:
-      if (!isa<CleanupPadInst>(Val)) {
-        P.Error(Loc, "'%" + Name + "' is not a cleanuppad");
-        return nullptr;
-      }
-      break;
-    }
     if (Val->getType() == Ty) return Val;
     if (Ty->isLabelTy())
       P.Error(Loc, "'%" + Name + "' is not a basic block");
     else
       P.Error(Loc, "'%" + Name + "' defined with type '" +
               getTypeString(Val->getType()) + "'");
     return nullptr;
   }
 
   // Don't make placeholders with invalid type.
   if (!Ty->isFirstClassType()) {
     P.Error(Loc, "invalid use of a non-first-class type");
     return nullptr;
   }
 
   // Otherwise, create a new forward reference for this value and remember it.
   Value *FwdVal;
   if (Ty->isLabelTy()) {
-    assert(!OC);
     FwdVal = BasicBlock::Create(F.getContext(), Name, &F);
-  } else if (!OC) {
-    FwdVal = new Argument(Ty, Name);
   } else {
-    switch (OC) {
-    case OC_CatchPad:
-      FwdVal = CatchPadInst::Create(&F.getEntryBlock(), &F.getEntryBlock(), {},
-                                    Name);
-      break;
-    case OC_CleanupPad:
-      FwdVal = CleanupPadInst::Create(F.getContext(), {}, Name);
-      break;
-    default:
-      llvm_unreachable("unexpected constraint");
-    }
+    FwdVal = new Argument(Ty, Name);
   }
 
   ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
   return FwdVal;
 }
 
-Value *LLParser::PerFunctionState::GetVal(unsigned ID, Type *Ty, LocTy Loc,
-                                          OperatorConstraint OC) {
+Value *LLParser::PerFunctionState::GetVal(unsigned ID, Type *Ty, LocTy Loc) {
   // Look this name up in the normal function symbol table.
   Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : nullptr;
 
   // If this is a forward reference for the value, see if we already created a
   // forward ref record.
   if (!Val) {
     auto I = ForwardRefValIDs.find(ID);
     if (I != ForwardRefValIDs.end())
       Val = I->second.first;
   }
 
   // If we have the value in the symbol table or fwd-ref table, return it.
   if (Val) {
-    // Check operator constraint.
-    switch (OC) {
-    case OC_None:
-      // no constraint
-      break;
-    case OC_CatchPad:
-      if (!isa<CatchPadInst>(Val)) {
-        P.Error(Loc, "'%" + Twine(ID) + "' is not a catchpad");
-        return nullptr;
-      }
-      break;
-    case OC_CleanupPad:
-      if (!isa<CleanupPadInst>(Val)) {
-        P.Error(Loc, "'%" + Twine(ID) + "' is not a cleanuppad");
-        return nullptr;
-      }
-      break;
-    }
     if (Val->getType() == Ty) return Val;
     if (Ty->isLabelTy())
       P.Error(Loc, "'%" + Twine(ID) + "' is not a basic block");
     else
       P.Error(Loc, "'%" + Twine(ID) + "' defined with type '" +
               getTypeString(Val->getType()) + "'");
     return nullptr;
   }
 
   if (!Ty->isFirstClassType()) {
     P.Error(Loc, "invalid use of a non-first-class type");
     return nullptr;
   }
 
   // Otherwise, create a new forward reference for this value and remember it.
   Value *FwdVal;
   if (Ty->isLabelTy()) {
-    assert(!OC);
     FwdVal = BasicBlock::Create(F.getContext(), "", &F);
-  } else if (!OC) {
-    FwdVal = new Argument(Ty);
   } else {
-    switch (OC) {
-    case OC_CatchPad:
-      FwdVal = CatchPadInst::Create(&F.getEntryBlock(), &F.getEntryBlock(), {});
-      break;
-    case OC_CleanupPad:
-      FwdVal = CleanupPadInst::Create(F.getContext(), {});
-      break;
-    default:
-      llvm_unreachable("unexpected constraint");
-    }
+    FwdVal = new Argument(Ty);
   }
 
   ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
   return FwdVal;
 }
 
 /// SetInstName - After an instruction is parsed and inserted into its
 /// basic block, this installs its name.
if (unsigned(NameID) != NumberedVals.size())
                      Twine(NumberedVals.size()) + "'");
 
     auto FI = ForwardRefValIDs.find(NameID);
     if (FI != ForwardRefValIDs.end()) {
       Value *Sentinel = FI->second.first;
       if (Sentinel->getType() != Inst->getType())
         return P.Error(NameLoc, "instruction forward referenced with type '" +
                        getTypeString(FI->second.first->getType()) + "'");
-      // Check operator constraints.  We only put cleanuppads or catchpads in
-      // the forward value map if the value is constrained to match.
-      if (isa<CatchPadInst>(Sentinel)) {
-        if (!isa<CatchPadInst>(Inst))
-          return P.Error(FI->second.second,
-                         "'%" + Twine(NameID) + "' is not a catchpad");
-      } else if (isa<CleanupPadInst>(Sentinel)) {
-        if (!isa<CleanupPadInst>(Inst))
-          return P.Error(FI->second.second,
-                         "'%" + Twine(NameID) + "' is not a cleanuppad");
-      }
 
       Sentinel->replaceAllUsesWith(Inst);
       delete Sentinel;
       ForwardRefValIDs.erase(FI);
     }
 
     NumberedVals.push_back(Inst);
     return false;
   }
 
   // Otherwise, the instruction had a name.  Resolve forward refs and set it.
   auto FI = ForwardRefVals.find(NameStr);
   if (FI != ForwardRefVals.end()) {
     Value *Sentinel = FI->second.first;
     if (Sentinel->getType() != Inst->getType())
       return P.Error(NameLoc, "instruction forward referenced with type '" +
                      getTypeString(FI->second.first->getType()) + "'");
-    // Check operator constraints.  We only put cleanuppads or catchpads in
-    // the forward value map if the value is constrained to match.
-    if (isa<CatchPadInst>(Sentinel)) {
-      if (!isa<CatchPadInst>(Inst))
-        return P.Error(FI->second.second,
-                       "'%" + NameStr + "' is not a catchpad");
-    } else if (isa<CleanupPadInst>(Sentinel)) {
-      if (!isa<CleanupPadInst>(Inst))
-        return P.Error(FI->second.second,
-                       "'%" + NameStr + "' is not a cleanuppad");
-    }
 
     Sentinel->replaceAllUsesWith(Inst);
     delete Sentinel;
     ForwardRefVals.erase(FI);
   }
 
   // Set the name on the instruction.
   Inst->setName(NameStr);

 }
 
 
 //===----------------------------------------------------------------------===//
 // Function Parsing.
 //===----------------------------------------------------------------------===//
 
 bool LLParser::ConvertValIDToValue(Type *Ty, ValID &ID, Value *&V,
-                                   PerFunctionState *PFS,
-                                   OperatorConstraint OC) {
+                                   PerFunctionState *PFS) {
   if (Ty->isFunctionTy())
     return Error(ID.Loc, "functions are not values, refer to them as pointers");
 
-  if (OC && ID.Kind != ValID::t_LocalID && ID.Kind != ValID::t_LocalName) {
-    switch (OC) {
-    case OC_CatchPad:
-      return Error(ID.Loc, "Catchpad value required in this position");
-    case OC_CleanupPad:
-      return Error(ID.Loc, "Cleanuppad value required in this position");
-    default:
-      llvm_unreachable("Unexpected constraint kind");
-    }
-  }
-
   switch (ID.Kind) {
   case ValID::t_LocalID:
     if (!PFS) return Error(ID.Loc, "invalid use of function-local name");
-    V = PFS->GetVal(ID.UIntVal, Ty, ID.Loc, OC);
+    V = PFS->GetVal(ID.UIntVal, Ty, ID.Loc);
     return V == nullptr;
   case ValID::t_LocalName:
     if (!PFS) return Error(ID.Loc, "invalid use of function-local name");
-    V = PFS->GetVal(ID.StrVal, Ty, ID.Loc, OC);
+    V = PFS->GetVal(ID.StrVal, Ty, ID.Loc);
     return V == nullptr;
   case ValID::t_InlineAsm: {
     if (!ID.FTy || !InlineAsm::Verify(ID.FTy, ID.StrVal2))
       return Error(ID.Loc, "invalid type for inline asm constraint string");
     V = InlineAsm::get(ID.FTy, ID.StrVal, ID.StrVal2, ID.UIntVal & 1,
                        (ID.UIntVal >> 1) & 1,
                        (InlineAsm::AsmDialect(ID.UIntVal >> 2)));
     return false;
case ValID::t_PackedConstantStruct: {
     C = cast<Constant>(V);
     return false;
   }
   default:
     return Error(Loc, "expected a constant value");
   }
 }
 
-bool LLParser::ParseValue(Type *Ty, Value *&V, PerFunctionState *PFS,
-                          OperatorConstraint OC) {
+bool LLParser::ParseValue(Type *Ty, Value *&V, PerFunctionState *PFS) {
   V = nullptr;
   ValID ID;
-  return ParseValID(ID, PFS) || ConvertValIDToValue(Ty, ID, V, PFS, OC);
+  return ParseValID(ID, PFS) || ConvertValIDToValue(Ty, ID, V, PFS);
 }
 
 bool LLParser::ParseTypeAndValue(Value *&V, PerFunctionState *PFS) {
   Type *Ty = nullptr;
   return ParseType(Ty) ||
          ParseValue(Ty, V, PFS);
 }
 
int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB,
   case lltok::kw_ret:         return ParseRet(Inst, BB, PFS);
   case lltok::kw_br:          return ParseBr(Inst, PFS);
   case lltok::kw_switch:      return ParseSwitch(Inst, PFS);
   case lltok::kw_indirectbr:  return ParseIndirectBr(Inst, PFS);
   case lltok::kw_invoke:      return ParseInvoke(Inst, PFS);
   case lltok::kw_resume:      return ParseResume(Inst, PFS);
   case lltok::kw_cleanupret:  return ParseCleanupRet(Inst, PFS);
   case lltok::kw_catchret:    return ParseCatchRet(Inst, PFS);
-  case lltok::kw_catchpad:  return ParseCatchPad(Inst, PFS);
-  case lltok::kw_terminatepad: return ParseTerminatePad(Inst, PFS);
-  case lltok::kw_cleanuppad: return ParseCleanupPad(Inst, PFS);
-  case lltok::kw_catchendpad: return ParseCatchEndPad(Inst, PFS);
-  case lltok::kw_cleanupendpad: return ParseCleanupEndPad(Inst, PFS);
+  case lltok::kw_catchswitch: return ParseCatchSwitch(Inst, PFS);
+  case lltok::kw_catchpad:    return ParseCatchPad(Inst, PFS);
+  case lltok::kw_terminatepad:return ParseTerminatePad(Inst, PFS);
+  case lltok::kw_cleanuppad:  return ParseCleanupPad(Inst, PFS);
   // Binary Operators.
   case lltok::kw_add:
   case lltok::kw_sub:
   case lltok::kw_mul:
   case lltok::kw_shl: {
     bool NUW = EatIfPresent(lltok::kw_nuw);
     bool NSW = EatIfPresent(lltok::kw_nsw);
     if (!NUW) NUW = EatIfPresent(lltok::kw_nuw);
while (Lex.getKind() != lltok::rsquare) {
     Args.push_back(V);
   }
 
   Lex.Lex();  // Lex the ']'.
   return false;
 }
 
 /// ParseCleanupRet
-///   ::= 'cleanupret' Value unwind ('to' 'caller' | TypeAndValue)
+///   ::= 'cleanupret' from Value unwind ('to' 'caller' | TypeAndValue)
 bool LLParser::ParseCleanupRet(Instruction *&Inst, PerFunctionState &PFS) {
   Value *CleanupPad = nullptr;
 
-  if (ParseValue(Type::getTokenTy(Context), CleanupPad, PFS, OC_CleanupPad))
+  if (ParseToken(lltok::kw_from, "expected 'from' after cleanupret"))
+    return true;
+
+  if (ParseValue(Type::getTokenTy(Context), CleanupPad, PFS))
     return true;
 
   if (ParseToken(lltok::kw_unwind, "expected 'unwind' in cleanupret"))
     return true;
 
   BasicBlock *UnwindBB = nullptr;
   if (Lex.getKind() == lltok::kw_to) {
     Lex.Lex();
     if (ParseToken(lltok::kw_caller, "expected 'caller' in cleanupret"))
       return true;
   } else {
     if (ParseTypeAndBasicBlock(UnwindBB, PFS)) {
       return true;
     }
   }
 
-  Inst = CleanupReturnInst::Create(cast<CleanupPadInst>(CleanupPad), UnwindBB);
+  Inst = CleanupReturnInst::Create(CleanupPad, UnwindBB);
   return false;
 }
 
 /// ParseCatchRet
-///   ::= 'catchret' Value 'to' TypeAndValue
+///   ::= 'catchret' from Parent Value 'to' TypeAndValue
 bool LLParser::ParseCatchRet(Instruction *&Inst, PerFunctionState &PFS) {
   Value *CatchPad = nullptr;
 
-  if (ParseValue(Type::getTokenTy(Context), CatchPad, PFS, OC_CatchPad))
+  if (ParseToken(lltok::kw_from, "expected 'from' after catchret"))
+    return true;
+
+  if (ParseValue(Type::getTokenTy(Context), CatchPad, PFS))
     return true;
 
   BasicBlock *BB;
   if (ParseToken(lltok::kw_to, "expected 'to' in catchret") ||
       ParseTypeAndBasicBlock(BB, PFS))
       return true;
 
-  Inst = CatchReturnInst::Create(cast<CatchPadInst>(CatchPad), BB);
+  Inst = CatchReturnInst::Create(CatchPad, BB);
   return false;
 }
 
-/// ParseCatchPad
-///   ::= 'catchpad' ParamList 'to' TypeAndValue 'unwind' TypeAndValue
-bool LLParser::ParseCatchPad(Instruction *&Inst, PerFunctionState &PFS) {
-  SmallVector<Value *, 8> Args;
-  if (ParseExceptionArgs(Args, PFS))
+/// ParseCatchSwitch
+///   ::= 'catchswitch' within Parent
+bool LLParser::ParseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS) {
+  Value *ParentPad;
+  LocTy BBLoc;
+
+  if (ParseToken(lltok::kw_within, "expected 'within' after catchswitch"))
     return true;
 
-  BasicBlock *NormalBB, *UnwindBB;
-  if (ParseToken(lltok::kw_to, "expected 'to' in catchpad") ||
-      ParseTypeAndBasicBlock(NormalBB, PFS) ||
-      ParseToken(lltok::kw_unwind, "expected 'unwind' in catchpad") ||
-      ParseTypeAndBasicBlock(UnwindBB, PFS))
+  if (Lex.getKind() != lltok::kw_none && Lex.getKind() != lltok::LocalVar &&
+      Lex.getKind() != lltok::LocalVarID)
+    return TokError("expected scope value for catchswitch");
+
+  if (ParseValue(Type::getTokenTy(Context), ParentPad, PFS))
     return true;
 
-  Inst = CatchPadInst::Create(NormalBB, UnwindBB, Args);
-  return false;
-}
+  if (ParseToken(lltok::lsquare, "expected '[' with catchswitch labels"))
+    return true;
 
-/// ParseTerminatePad
-///   ::= 'terminatepad' ParamList 'to' TypeAndValue
-bool LLParser::ParseTerminatePad(Instruction *&Inst, PerFunctionState &PFS) {
-  SmallVector<Value *, 8> Args;
-  if (ParseExceptionArgs(Args, PFS))
+  SmallVector<BasicBlock *, 32> Table;
+  do {
+    BasicBlock *DestBB;
+    if (ParseTypeAndBasicBlock(DestBB, PFS))
       return true;
+    Table.push_back(DestBB);
+  } while (EatIfPresent(lltok::comma));
 
-  if (ParseToken(lltok::kw_unwind, "expected 'unwind' in terminatepad"))
+  if (ParseToken(lltok::rsquare, "expected ']' after catchswitch labels"))
+    return true;
+
+  if (ParseToken(lltok::kw_unwind,
+                 "expected 'unwind' after catchswitch scope"))
     return true;
 
   BasicBlock *UnwindBB = nullptr;
-  if (Lex.getKind() == lltok::kw_to) {
-    Lex.Lex();
-    if (ParseToken(lltok::kw_caller, "expected 'caller' in terminatepad"))
+  if (EatIfPresent(lltok::kw_to)) {
+    if (ParseToken(lltok::kw_caller, "expected 'caller' in catchswitch"))
       return true;
   } else {
-    if (ParseTypeAndBasicBlock(UnwindBB, PFS)) {
+    if (ParseTypeAndBasicBlock(UnwindBB, PFS))
       return true;
-    }
-  }
 
-  Inst = TerminatePadInst::Create(Context, UnwindBB, Args);
+  auto *CatchSwitch =
+      CatchSwitchInst::Create(ParentPad, UnwindBB, Table.size());
+  for (BasicBlock *DestBB : Table)
+    CatchSwitch->addHandler(DestBB);
+  Inst = CatchSwitch;
   return false;
 }
 
-/// ParseCleanupPad
-///   ::= 'cleanuppad' ParamList
-bool LLParser::ParseCleanupPad(Instruction *&Inst, PerFunctionState &PFS) {
+/// ParseCatchPad
+///   ::= 'catchpad' ParamList 'to' TypeAndValue 'unwind' TypeAndValue
+bool LLParser::ParseCatchPad(Instruction *&Inst, PerFunctionState &PFS) {
+  Value *CatchSwitch = nullptr;
+
+  if (ParseToken(lltok::kw_within, "expected 'within' after catchpad"))
+    return true;
+
+  if (Lex.getKind() != lltok::LocalVar && Lex.getKind() != lltok::LocalVarID)
+    return TokError("expected scope value for catchpad");
+
+  if (ParseValue(Type::getTokenTy(Context), CatchSwitch, PFS))
+    return true;
+
   SmallVector<Value *, 8> Args;
   if (ParseExceptionArgs(Args, PFS))
     return true;
 
-  Inst = CleanupPadInst::Create(Context, Args);
+  Inst = CatchPadInst::Create(CatchSwitch, Args);
   return false;
 }
 
-/// ParseCatchEndPad
-///   ::= 'catchendpad' unwind ('to' 'caller' | TypeAndValue)
-bool LLParser::ParseCatchEndPad(Instruction *&Inst, PerFunctionState &PFS) {
-  if (ParseToken(lltok::kw_unwind, "expected 'unwind' in catchendpad"))
+/// ParseTerminatePad
+///   ::= 'terminatepad' within Parent ParamList 'to' TypeAndValue
+bool LLParser::ParseTerminatePad(Instruction *&Inst, PerFunctionState &PFS) {
+  Value *ParentPad = nullptr;
+
+  if (ParseToken(lltok::kw_within, "expected 'within' after terminatepad"))
+    return true;
+
+  if (Lex.getKind() != lltok::kw_none && Lex.getKind() != lltok::LocalVar &&
+      Lex.getKind() != lltok::LocalVarID)
+    return TokError("expected scope value for terminatepad");
+
+  if (ParseValue(Type::getTokenTy(Context), ParentPad, PFS))
+    return true;
+
+  SmallVector<Value *, 8> Args;
+  if (ParseExceptionArgs(Args, PFS))
+    return true;
+
+  if (ParseToken(lltok::kw_unwind, "expected 'unwind' in terminatepad"))
     return true;
 
   BasicBlock *UnwindBB = nullptr;
   if (Lex.getKind() == lltok::kw_to) {
     Lex.Lex();
-    if (Lex.getKind() == lltok::kw_caller) {
-      Lex.Lex();
-    } else {
+    if (ParseToken(lltok::kw_caller, "expected 'caller' in terminatepad"))
       return true;
-    }
   } else {
     if (ParseTypeAndBasicBlock(UnwindBB, PFS)) {
       return true;
     }
   }
 
-  Inst = CatchEndPadInst::Create(Context, UnwindBB);
+  Inst = TerminatePadInst::Create(ParentPad, UnwindBB, Args);
   return false;
 }
 
-/// ParseCatchEndPad
-///   ::= 'cleanupendpad' Value unwind ('to' 'caller' | TypeAndValue)
-bool LLParser::ParseCleanupEndPad(Instruction *&Inst, PerFunctionState &PFS) {
-  Value *CleanupPad = nullptr;
+/// ParseCleanupPad
+///   ::= 'cleanuppad' within Parent ParamList
+bool LLParser::ParseCleanupPad(Instruction *&Inst, PerFunctionState &PFS) {
+  Value *ParentPad = nullptr;
 
-  if (ParseValue(Type::getTokenTy(Context), CleanupPad, PFS, OC_CleanupPad))
+  if (ParseToken(lltok::kw_within, "expected 'within' after cleanuppad"))
     return true;
 
-  if (ParseToken(lltok::kw_unwind, "expected 'unwind' in catchendpad"))
-    return true;
+  if (Lex.getKind() != lltok::kw_none && Lex.getKind() != lltok::LocalVar &&
+      Lex.getKind() != lltok::LocalVarID)
+    return TokError("expected scope value for cleanuppad");
 
-  BasicBlock *UnwindBB = nullptr;
-  if (Lex.getKind() == lltok::kw_to) {
-    Lex.Lex();
-    if (Lex.getKind() == lltok::kw_caller) {
-      Lex.Lex();
-    } else {
-      return true;
-    }
-  } else {
-    if (ParseTypeAndBasicBlock(UnwindBB, PFS)) {
-      return true;
-    }
-  }
+  if (ParseValue(Type::getTokenTy(Context), ParentPad, PFS))
+
+  SmallVector<Value *, 8> Args;
+  if (ParseExceptionArgs(Args, PFS))
 
-  Inst = CleanupEndPadInst::Create(cast<CleanupPadInst>(CleanupPad), UnwindBB);
+  Inst = CleanupPadInst::Create(ParentPad, Args);
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // Binary Operators.
 //===----------------------------------------------------------------------===//
 
 /// ParseArithmetic

llvm/trunk/lib/AsmParser/LLToken.h

enum Kind {
     kw_externally_initialized,
     kw_extern_weak,
     kw_external, kw_thread_local,
     kw_localdynamic, kw_initialexec, kw_localexec,
     kw_zeroinitializer,
     kw_undef, kw_null, kw_none,
     kw_to,
     kw_caller,
+    kw_within,
+    kw_from,
     kw_tail,
     kw_musttail,
     kw_notail,
     kw_target,
     kw_triple,
     kw_unwind,
     kw_deplibs,                 // FIXME: Remove in 4.0
     kw_datalayout,
enum Kind {
     kw_trunc, kw_zext, kw_sext, kw_fptrunc, kw_fpext, kw_uitofp, kw_sitofp,
     kw_fptoui, kw_fptosi, kw_inttoptr, kw_ptrtoint, kw_bitcast,
     kw_addrspacecast,
     kw_select, kw_va_arg,
 
     kw_landingpad, kw_personality, kw_cleanup, kw_catch, kw_filter,
 
     kw_ret, kw_br, kw_switch, kw_indirectbr, kw_invoke, kw_resume,
-    kw_unreachable, kw_cleanupret, kw_catchret, kw_catchpad,
-    kw_terminatepad, kw_cleanuppad, kw_catchendpad, kw_cleanupendpad,
+    kw_unreachable, kw_cleanupret, kw_catchswitch, kw_catchret, kw_catchpad,
+    kw_terminatepad, kw_cleanuppad,
 
     kw_alloca, kw_load, kw_store, kw_fence, kw_cmpxchg, kw_atomicrmw,
     kw_getelementptr,
 
     kw_extractelement, kw_insertelement, kw_shufflevector,
     kw_extractvalue, kw_insertvalue, kw_blockaddress,
 
     // Metadata types.

llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp

 #include <deque>
 using namespace llvm;
 
 namespace {
 enum {
   SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex
 };
 
-/// Indicates which operator an operand allows (for the few operands that may
-/// only reference a certain operator).
-enum OperatorConstraint {
-  OC_None = 0,  // No constraint
-  OC_CatchPad,  // Must be CatchPadInst
-  OC_CleanupPad // Must be CleanupPadInst
-};
-
 class BitcodeReaderValueList {
   std::vector<WeakVH> ValuePtrs;
 
   /// As we resolve forward-referenced constants, we add information about them
   /// to this vector.  This allows us to resolve them in bulk instead of
   /// resolving each reference at a time.  See the code in
   /// ResolveConstantForwardRefs for more information about this.
   ///
Value *back() const { return ValuePtrs.back(); }
     void pop_back() { ValuePtrs.pop_back(); }
   bool empty() const { return ValuePtrs.empty(); }
   void shrinkTo(unsigned N) {
     assert(N <= size() && "Invalid shrinkTo request!");
     ValuePtrs.resize(N);
   }
 
   Constant *getConstantFwdRef(unsigned Idx, Type *Ty);
-  Value *getValueFwdRef(unsigned Idx, Type *Ty,
-                        OperatorConstraint OC = OC_None);
+  Value *getValueFwdRef(unsigned Idx, Type *Ty);
 
-  bool assignValue(Value *V, unsigned Idx);
+  void assignValue(Value *V, unsigned Idx);
 
   /// Once all constants are read, this method bulk resolves any forward
   /// references.
   void resolveConstantForwardRefs();
 };
 
 class BitcodeReaderMDValueList {
   unsigned NumFwdRefs;
private:
   // "epoch" encoded in the bitcode.
   std::error_code parseBitcodeVersion();
 
   std::vector<StructType *> IdentifiedStructTypes;
   StructType *createIdentifiedStructType(LLVMContext &Context, StringRef Name);
   StructType *createIdentifiedStructType(LLVMContext &Context);
 
   Type *getTypeByID(unsigned ID);
-  Value *getFnValueByID(unsigned ID, Type *Ty,
-                        OperatorConstraint OC = OC_None) {
+  Value *getFnValueByID(unsigned ID, Type *Ty) {
     if (Ty && Ty->isMetadataTy())
       return MetadataAsValue::get(Ty->getContext(), getFnMetadataByID(ID));
-    return ValueList.getValueFwdRef(ID, Ty, OC);
+    return ValueList.getValueFwdRef(ID, Ty);
   }
   Metadata *getFnMetadataByID(unsigned ID) {
     return MDValueList.getValueFwdRef(ID);
   }
   BasicBlock *getBasicBlock(unsigned ID) const {
     if (ID >= FunctionBBs.size()) return nullptr; // Invalid ID
     return FunctionBBs[ID];
   }
bool getValueTypePair(SmallVectorImpl<uint64_t> &Record, unsigned &Slot,
     ResVal = getFnValueByID(ValNo, getTypeByID(TypeNo));
     return ResVal == nullptr;
   }
 
   /// Read a value out of the specified record from slot 'Slot'. Increment Slot
   /// past the number of slots used by the value in the record. Return true if
   /// there is an error.
   bool popValue(SmallVectorImpl<uint64_t> &Record, unsigned &Slot,
-                unsigned InstNum, Type *Ty, Value *&ResVal,
-                OperatorConstraint OC = OC_None) {
-    if (getValue(Record, Slot, InstNum, Ty, ResVal, OC))
+                unsigned InstNum, Type *Ty, Value *&ResVal) {
+    if (getValue(Record, Slot, InstNum, Ty, ResVal))
       return true;
     // All values currently take a single record slot.
     ++Slot;
     return false;
   }
 
   /// Like popValue, but does not increment the Slot number.
   bool getValue(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
-                unsigned InstNum, Type *Ty, Value *&ResVal,
-                OperatorConstraint OC = OC_None) {
-    ResVal = getValue(Record, Slot, InstNum, Ty, OC);
+                unsigned InstNum, Type *Ty, Value *&ResVal) {
+    ResVal = getValue(Record, Slot, InstNum, Ty);
     return ResVal == nullptr;
   }
 
   /// Version of getValue that returns ResVal directly, or 0 if there is an
   /// error.
   Value *getValue(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
-                  unsigned InstNum, Type *Ty, OperatorConstraint OC = OC_None) {
+                  unsigned InstNum, Type *Ty) {
     if (Slot == Record.size()) return nullptr;
     unsigned ValNo = (unsigned)Record[Slot];
     // Adjust the ValNo, if it was encoded relative to the InstNum.
     if (UseRelativeIDs)
       ValNo = InstNum - ValNo;
-    return getFnValueByID(ValNo, Ty, OC);
+    return getFnValueByID(ValNo, Ty);
   }
 
   /// Like getValue, but decodes signed VBRs.
   Value *getValueSigned(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
-                        unsigned InstNum, Type *Ty,
-                        OperatorConstraint OC = OC_None) {
+                        unsigned InstNum, Type *Ty) {
     if (Slot == Record.size()) return nullptr;
     unsigned ValNo = (unsigned)decodeSignRotatedValue(Record[Slot]);
     // Adjust the ValNo, if it was encoded relative to the InstNum.
     if (UseRelativeIDs)
       ValNo = InstNum - ValNo;
-    return getFnValueByID(ValNo, Ty, OC);
+    return getFnValueByID(ValNo, Ty);
   }
 
   /// Converts alignment exponent (i.e. power of two (or zero)) to the
   /// corresponding alignment to use. If alignment is too large, returns
   /// a corresponding error code.
   std::error_code parseAlignmentValue(uint64_t Exponent, unsigned &Alignment);
   std::error_code parseAttrKind(uint64_t Code, Attribute::AttrKind *Kind);
   std::error_code parseModule(uint64_t ResumeBit,

 // FIXME: can we inherit this from ConstantExpr?
 template <>
 struct OperandTraits<ConstantPlaceHolder> :
   public FixedNumOperandTraits<ConstantPlaceHolder, 1> {
 };
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantPlaceHolder, Value)
 }
 
-bool BitcodeReaderValueList::assignValue(Value *V, unsigned Idx) {
+void BitcodeReaderValueList::assignValue(Value *V, unsigned Idx) {
   if (Idx == size()) {
     push_back(V);
-    return false;
+    return;
   }
 
   if (Idx >= size())
     resize(Idx+1);
 
   WeakVH &OldV = ValuePtrs[Idx];
   if (!OldV) {
     OldV = V;
-    return false;
+    return;
   }
 
   // Handle constants and non-constants (e.g. instrs) differently for
   // efficiency.
   if (Constant *PHC = dyn_cast<Constant>(&*OldV)) {
     ResolveConstants.push_back(std::make_pair(PHC, Idx));
     OldV = V;
   } else {
     // If there was a forward reference to this value, replace it.
     Value *PrevVal = OldV;
-    // Check operator constraints.  We only put cleanuppads or catchpads in
-    // the forward value map if the value is constrained to match.
-    if (CatchPadInst *CatchPad = dyn_cast<CatchPadInst>(PrevVal)) {
-      if (!isa<CatchPadInst>(V))
-        return true;
-      // Delete the dummy basic block that was created with the sentinel
-      // catchpad.
-      BasicBlock *DummyBlock = CatchPad->getUnwindDest();
-      assert(DummyBlock == CatchPad->getNormalDest());
-      CatchPad->dropAllReferences();
-      delete DummyBlock;
-    } else if (isa<CleanupPadInst>(PrevVal)) {
-      if (!isa<CleanupPadInst>(V))
-        return true;
-    }
     OldV->replaceAllUsesWith(V);
     delete PrevVal;
   }
 
-  return false;
+  return;
 }
 
 
 Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx,
                                                     Type *Ty) {
   if (Idx >= size())
     resize(Idx + 1);
 
   if (Value *V = ValuePtrs[Idx]) {
     if (Ty != V->getType())
       report_fatal_error("Type mismatch in constant table!");
     return cast<Constant>(V);
   }
 
   // Create and return a placeholder, which will later be RAUW'd.
   Constant *C = new ConstantPlaceHolder(Ty, Context);
   ValuePtrs[Idx] = C;
   return C;
 }
 
-Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty,
-                                              OperatorConstraint OC) {
+Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) {
   // Bail out for a clearly invalid value. This would make us call resize(0)
   if (Idx == UINT_MAX)
     return nullptr;
 
   if (Idx >= size())
     resize(Idx + 1);
 
   if (Value *V = ValuePtrs[Idx]) {
     // If the types don't match, it's invalid.
     if (Ty && Ty != V->getType())
       return nullptr;
-    if (!OC)
-      return V;
-    // Use dyn_cast to enforce operator constraints
-    switch (OC) {
-    case OC_CatchPad:
-      return dyn_cast<CatchPadInst>(V);
-    case OC_CleanupPad:
-      return dyn_cast<CleanupPadInst>(V);
-    default:
-      llvm_unreachable("Unexpected operator constraint");
-    }
   }
 
   // No type specified, must be invalid reference.
   if (!Ty) return nullptr;
 
   // Create and return a placeholder, which will later be RAUW'd.
-  Value *V;
-  switch (OC) {
-  case OC_None:
-    V = new Argument(Ty);
-    break;
-  case OC_CatchPad: {
-    BasicBlock *BB = BasicBlock::Create(Context);
-    V = CatchPadInst::Create(BB, BB, {});
-    break;
-  }
-  default:
-    assert(OC == OC_CleanupPad && "unexpected operator constraint");
-    V = CleanupPadInst::Create(Context, {});
-    break;
-  }
-
+  Value *V = new Argument(Ty);
   ValuePtrs[Idx] = V;
   return V;
 }
 
 /// Once all constants are read, this method bulk resolves any forward
 /// references.  The idea behind this is that we sometimes get constants (such
 /// as large arrays) which reference *many* forward ref constants.  Replacing
 /// each of these causes a lot of thrashing when building/reuniquing the
case bitc::CST_CODE_BLOCKADDRESS:{
           FwdBBs[BBID] = BasicBlock::Create(Context);
         BB = FwdBBs[BBID];
       }
       V = BlockAddress::get(Fn, BB);
       break;
     }
     }
 
-    if (ValueList.assignValue(V, NextCstNo))
-      return error("Invalid forward reference");
+    ValueList.assignValue(V, NextCstNo);
     ++NextCstNo;
   }
 }
 
 std::error_code BitcodeReader::parseUseLists() {
   if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID))
     return error("Invalid record");
 
case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
         InstructionList.push_back(I);
       }
       break;
     }
     case bitc::FUNC_CODE_INST_CLEANUPRET: { // CLEANUPRET: [val] or [val,bb#]
       if (Record.size() != 1 && Record.size() != 2)
         return error("Invalid record");
       unsigned Idx = 0;
-      Value *CleanupPad = getValue(Record, Idx++, NextValueNo,
-                                   Type::getTokenTy(Context), OC_CleanupPad);
+      Value *CleanupPad =
+          getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
       if (!CleanupPad)
         return error("Invalid record");
       BasicBlock *UnwindDest = nullptr;
       if (Record.size() == 2) {
         UnwindDest = getBasicBlock(Record[Idx++]);
         if (!UnwindDest)
           return error("Invalid record");
       }
 
-      I = CleanupReturnInst::Create(cast<CleanupPadInst>(CleanupPad),
-                                    UnwindDest);
+      I = CleanupReturnInst::Create(CleanupPad, UnwindDest);
       InstructionList.push_back(I);
       break;
     }
     case bitc::FUNC_CODE_INST_CATCHRET: { // CATCHRET: [val,bb#]
       if (Record.size() != 2)
         return error("Invalid record");
       unsigned Idx = 0;
-      Value *CatchPad = getValue(Record, Idx++, NextValueNo,
-                                 Type::getTokenTy(Context), OC_CatchPad);
+      Value *CatchPad =
+          getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
       if (!CatchPad)
         return error("Invalid record");
       BasicBlock *BB = getBasicBlock(Record[Idx++]);
       if (!BB)
         return error("Invalid record");
 
-      I = CatchReturnInst::Create(cast<CatchPadInst>(CatchPad), BB);
+      I = CatchReturnInst::Create(CatchPad, BB);
       InstructionList.push_back(I);
       break;
     }
-    case bitc::FUNC_CODE_INST_CATCHPAD: { // CATCHPAD: [bb#,bb#,num,(ty,val)*]
-      if (Record.size() < 3)
+    case bitc::FUNC_CODE_INST_CATCHSWITCH: { // CATCHSWITCH: [tok,num,(bb)*,bb?]
+      // We must have, at minimum, the outer scope and the number of arguments.
+      if (Record.size() < 2)
         return error("Invalid record");
+
       unsigned Idx = 0;
-      BasicBlock *NormalBB = getBasicBlock(Record[Idx++]);
-      if (!NormalBB)
-        return error("Invalid record");
-      BasicBlock *UnwindBB = getBasicBlock(Record[Idx++]);
-      if (!UnwindBB)
+
+      Value *ParentPad =
+          getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
+
+      unsigned NumHandlers = Record[Idx++];
+
+      SmallVector<BasicBlock *, 2> Handlers;
+      for (unsigned Op = 0; Op != NumHandlers; ++Op) {
+        BasicBlock *BB = getBasicBlock(Record[Idx++]);
+        if (!BB)
           return error("Invalid record");
-      unsigned NumArgOperands = Record[Idx++];
-      SmallVector<Value *, 2> Args;
-      for (unsigned Op = 0; Op != NumArgOperands; ++Op) {
-        Value *Val;
-        if (getValueTypePair(Record, Idx, NextValueNo, Val))
+        Handlers.push_back(BB);
+      }
+
+      BasicBlock *UnwindDest = nullptr;
+      if (Idx + 1 == Record.size()) {
+        UnwindDest = getBasicBlock(Record[Idx++]);
+        if (!UnwindDest)
           return error("Invalid record");
-        Args.push_back(Val);
       }
+
       if (Record.size() != Idx)
         return error("Invalid record");
 
-      I = CatchPadInst::Create(NormalBB, UnwindBB, Args);
+      auto *CatchSwitch =
+          CatchSwitchInst::Create(ParentPad, UnwindDest, NumHandlers);
+      for (BasicBlock *Handler : Handlers)
+        CatchSwitch->addHandler(Handler);
+      I = CatchSwitch;
       InstructionList.push_back(I);
       break;
     }
-    case bitc::FUNC_CODE_INST_TERMINATEPAD: { // TERMINATEPAD: [bb#,num,(ty,val)*]
-      if (Record.size() < 1)
+    case bitc::FUNC_CODE_INST_TERMINATEPAD: { // TERMINATEPAD: [tok,bb#,num,(ty,val)*]
+      // We must have, at minimum, the outer scope and the number of arguments.
+      if (Record.size() < 2)
         return error("Invalid record");
+
       unsigned Idx = 0;
-      bool HasUnwindDest = !!Record[Idx++];
-      BasicBlock *UnwindDest = nullptr;
-      if (HasUnwindDest) {
-        if (Idx == Record.size())
-          return error("Invalid record");
-        UnwindDest = getBasicBlock(Record[Idx++]);
-        if (!UnwindDest)
-          return error("Invalid record");
-      }
+
+      Value *ParentPad =
+          getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
+
       unsigned NumArgOperands = Record[Idx++];
+
       SmallVector<Value *, 2> Args;
       for (unsigned Op = 0; Op != NumArgOperands; ++Op) {
         Value *Val;
         if (getValueTypePair(Record, Idx, NextValueNo, Val))
           return error("Invalid record");
         Args.push_back(Val);
       }
+
+      BasicBlock *UnwindDest = nullptr;
+      if (Idx + 1 == Record.size()) {
+        UnwindDest = getBasicBlock(Record[Idx++]);
+        if (!UnwindDest)
+          return error("Invalid record");
+      }
+
       if (Record.size() != Idx)
         return error("Invalid record");
 
-      I = TerminatePadInst::Create(Context, UnwindDest, Args);
+      I = TerminatePadInst::Create(ParentPad, UnwindDest, Args);
       InstructionList.push_back(I);
       break;
     }
-    case bitc::FUNC_CODE_INST_CLEANUPPAD: { // CLEANUPPAD: [num,(ty,val)*]
-      if (Record.size() < 1)
+    case bitc::FUNC_CODE_INST_CATCHPAD:
+    case bitc::FUNC_CODE_INST_CLEANUPPAD: { // [tok,num,(ty,val)*]
+      // We must have, at minimum, the outer scope and the number of arguments.
+      if (Record.size() < 2)
         return error("Invalid record");
+
       unsigned Idx = 0;
+
+      Value *ParentPad =
+          getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
+
       unsigned NumArgOperands = Record[Idx++];
+
       SmallVector<Value *, 2> Args;
       for (unsigned Op = 0; Op != NumArgOperands; ++Op) {
         Value *Val;
         if (getValueTypePair(Record, Idx, NextValueNo, Val))
           return error("Invalid record");
         Args.push_back(Val);
       }
-      if (Record.size() != Idx)
-        return error("Invalid record");
 
-      I = CleanupPadInst::Create(Context, Args);
-      InstructionList.push_back(I);
-      break;
-    }
-    case bitc::FUNC_CODE_INST_CATCHENDPAD: { // CATCHENDPADINST: [bb#] or []
-      if (Record.size() > 1)
-        return error("Invalid record");
-      BasicBlock *BB = nullptr;
-      if (Record.size() == 1) {
-        BB = getBasicBlock(Record[0]);
-        if (!BB)
-          return error("Invalid record");
-      }
-      I = CatchEndPadInst::Create(Context, BB);
-      InstructionList.push_back(I);
-      break;
-    }
-    case bitc::FUNC_CODE_INST_CLEANUPENDPAD: { // CLEANUPENDPADINST: [val] or [val,bb#]
-      if (Record.size() != 1 && Record.size() != 2)
-        return error("Invalid record");
-      unsigned Idx = 0;
-      Value *CleanupPad = getValue(Record, Idx++, NextValueNo,
-                                   Type::getTokenTy(Context), OC_CleanupPad);
-      if (!CleanupPad)
+      if (Record.size() != Idx)
         return error("Invalid record");
 
-      BasicBlock *BB = nullptr;
-      if (Record.size() == 2) {
-        BB = getBasicBlock(Record[Idx++]);
-        if (!BB)
-          return error("Invalid record");
-      }
-      I = CleanupEndPadInst::Create(cast<CleanupPadInst>(CleanupPad), BB);
+      if (BitCode == bitc::FUNC_CODE_INST_CLEANUPPAD)
+        I = CleanupPadInst::Create(ParentPad, Args);
+      else
+        I = CatchPadInst::Create(ParentPad, Args);
       InstructionList.push_back(I);
       break;
     }
     case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...]
       // Check magic
       if ((Record[0] >> 16) == SWITCH_INST_MAGIC) {
         // "New" SwitchInst format with case ranges. The changes to write this
         // format were reverted but we still recognize bitcode that uses it.

     // If this was a terminator instruction, move to the next block.
     if (isa<TerminatorInst>(I)) {
       ++CurBBNo;
       CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : nullptr;
     }
 
     // Non-void values get registered in the value table for future use.
     if (I && !I->getType()->isVoidTy())
-      if (ValueList.assignValue(I, NextValueNo++))
-        return error("Invalid forward reference");
+      ValueList.assignValue(I, NextValueNo++);
   }
 
 OutOfRecordLoop:
 
   if (!OperandBundles.empty())
     return error("Operand bundles found with no consumer");
 
   // Check the function list for unresolved values.

llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp

static void WriteInstruction(const Instruction &I, unsigned InstID,
   }
   case Instruction::CatchRet: {
     Code = bitc::FUNC_CODE_INST_CATCHRET;
     const auto &CRI = cast<CatchReturnInst>(I);
     pushValue(CRI.getCatchPad(), InstID, Vals, VE);
     Vals.push_back(VE.getValueID(CRI.getSuccessor()));
     break;
   }
+  case Instruction::CleanupPad:
   case Instruction::CatchPad: {
-    Code = bitc::FUNC_CODE_INST_CATCHPAD;
-    const auto &CPI = cast<CatchPadInst>(I);
-    Vals.push_back(VE.getValueID(CPI.getNormalDest()));
-    Vals.push_back(VE.getValueID(CPI.getUnwindDest()));
-    unsigned NumArgOperands = CPI.getNumArgOperands();
+    const auto &FuncletPad = cast<FuncletPadInst>(I);
+    Code = isa<CatchPadInst>(FuncletPad) ? bitc::FUNC_CODE_INST_CATCHPAD
+                                         : bitc::FUNC_CODE_INST_CLEANUPPAD;
+    pushValue(FuncletPad.getParentPad(), InstID, Vals, VE);
+
+    unsigned NumArgOperands = FuncletPad.getNumArgOperands();
     Vals.push_back(NumArgOperands);
     for (unsigned Op = 0; Op != NumArgOperands; ++Op)
-      PushValueAndType(CPI.getArgOperand(Op), InstID, Vals, VE);
+      PushValueAndType(FuncletPad.getArgOperand(Op), InstID, Vals, VE);
+    break;
+  }
+  case Instruction::CatchSwitch: {
+    Code = bitc::FUNC_CODE_INST_CATCHSWITCH;
+    const auto &CatchSwitch = cast<CatchSwitchInst>(I);
+
+    pushValue(CatchSwitch.getParentPad(), InstID, Vals, VE);
+
+    unsigned NumHandlers = CatchSwitch.getNumHandlers();
+    Vals.push_back(NumHandlers);
+    for (const BasicBlock *CatchPadBB : CatchSwitch.handlers())
+      Vals.push_back(VE.getValueID(CatchPadBB));
+
+    if (CatchSwitch.hasUnwindDest())
+      Vals.push_back(VE.getValueID(CatchSwitch.getUnwindDest()));
     break;
   }
   case Instruction::TerminatePad: {
     Code = bitc::FUNC_CODE_INST_TERMINATEPAD;
     const auto &TPI = cast<TerminatePadInst>(I);
-    Vals.push_back(TPI.hasUnwindDest());
-    if (TPI.hasUnwindDest())
-      Vals.push_back(VE.getValueID(TPI.getUnwindDest()));
+
+    pushValue(TPI.getParentPad(), InstID, Vals, VE);
+
     unsigned NumArgOperands = TPI.getNumArgOperands();
     Vals.push_back(NumArgOperands);
     for (unsigned Op = 0; Op != NumArgOperands; ++Op)
       PushValueAndType(TPI.getArgOperand(Op), InstID, Vals, VE);
-    break;
-  }
-  case Instruction::CleanupPad: {
-    Code = bitc::FUNC_CODE_INST_CLEANUPPAD;
-    const auto &CPI = cast<CleanupPadInst>(I);
-    unsigned NumOperands = CPI.getNumOperands();
-    Vals.push_back(NumOperands);
-    for (unsigned Op = 0; Op != NumOperands; ++Op)
-      PushValueAndType(CPI.getOperand(Op), InstID, Vals, VE);
-    break;
-  }
-  case Instruction::CatchEndPad: {
-    Code = bitc::FUNC_CODE_INST_CATCHENDPAD;
-    const auto &CEPI = cast<CatchEndPadInst>(I);
-    if (CEPI.hasUnwindDest())
-      Vals.push_back(VE.getValueID(CEPI.getUnwindDest()));
-    break;
-  }
-  case Instruction::CleanupEndPad: {
-    Code = bitc::FUNC_CODE_INST_CLEANUPENDPAD;
-    const auto &CEPI = cast<CleanupEndPadInst>(I);
-    pushValue(CEPI.getCleanupPad(), InstID, Vals, VE);
-    if (CEPI.hasUnwindDest())
-      Vals.push_back(VE.getValueID(CEPI.getUnwindDest()));
+
+    if (TPI.hasUnwindDest())
+      Vals.push_back(VE.getValueID(TPI.getUnwindDest()));
     break;
   }
   case Instruction::Unreachable:
     Code = bitc::FUNC_CODE_INST_UNREACHABLE;
     AbbrevToUse = FUNCTION_INST_UNREACHABLE_ABBREV;
     break;
 
   case Instruction::PHI: {

llvm/trunk/lib/CodeGen/AsmPrinter/WinException.cpp

 /// as being in the NullState even if there's not an unwind-to-caller call
 /// before the first invoke or after the last one (i.e., the first state change
 /// reported is the first change to something other than NullState, and a
 /// change back to NullState is always reported at the end of iteration).
 class InvokeStateChangeIterator {
   InvokeStateChangeIterator(const WinEHFuncInfo &EHInfo,
                             MachineFunction::const_iterator MFI,
                             MachineFunction::const_iterator MFE,
-                            MachineBasicBlock::const_iterator MBBI)
-      : EHInfo(EHInfo), MFI(MFI), MFE(MFE), MBBI(MBBI) {
+                            MachineBasicBlock::const_iterator MBBI,
+                            int BaseState)
+      : EHInfo(EHInfo), MFI(MFI), MFE(MFE), MBBI(MBBI), BaseState(BaseState) {
     LastStateChange.PreviousEndLabel = nullptr;
     LastStateChange.NewStartLabel = nullptr;
-    LastStateChange.NewState = NullState;
+    LastStateChange.NewState = BaseState;
     scan();
   }
 
 public:
   static iterator_range<InvokeStateChangeIterator>
-  range(const WinEHFuncInfo &EHInfo, const MachineFunction &MF) {
-    // Reject empty MFs to simplify bookkeeping by ensuring that we can get the
-    // end of the last block.
-    assert(!MF.empty());
-    auto FuncBegin = MF.begin();
-    auto FuncEnd = MF.end();
-    auto BlockBegin = FuncBegin->begin();
-    auto BlockEnd = MF.back().end();
-    return make_range(
-        InvokeStateChangeIterator(EHInfo, FuncBegin, FuncEnd, BlockBegin),
-        InvokeStateChangeIterator(EHInfo, FuncEnd, FuncEnd, BlockEnd));
-  }
-  static iterator_range<InvokeStateChangeIterator>
   range(const WinEHFuncInfo &EHInfo, MachineFunction::const_iterator Begin,
-        MachineFunction::const_iterator End) {
+        MachineFunction::const_iterator End, int BaseState = NullState) {
     // Reject empty ranges to simplify bookkeeping by ensuring that we can get
     // the end of the last block.
     assert(Begin != End);
     auto BlockBegin = Begin->begin();
     auto BlockEnd = std::prev(End)->end();
-    return make_range(InvokeStateChangeIterator(EHInfo, Begin, End, BlockBegin),
-                      InvokeStateChangeIterator(EHInfo, End, End, BlockEnd));
+    return make_range(
+        InvokeStateChangeIterator(EHInfo, Begin, End, BlockBegin, BaseState),
+        InvokeStateChangeIterator(EHInfo, End, End, BlockEnd, BaseState));
   }
 
   // Iterator methods.
   bool operator==(const InvokeStateChangeIterator &O) const {
+    assert(BaseState == O.BaseState);
     // Must be visiting same block.
     if (MFI != O.MFI)
       return false;
     // Must be visiting same isntr.
     if (MBBI != O.MBBI)
       return false;
     // At end of block/instr iteration, we can still have two distinct states:
     // one to report the final EndLabel, and another indicating the end of the
private:
 
   const WinEHFuncInfo &EHInfo;
   const MCSymbol *CurrentEndLabel = nullptr;
   MachineFunction::const_iterator MFI;
   MachineFunction::const_iterator MFE;
   MachineBasicBlock::const_iterator MBBI;
   InvokeStateChange LastStateChange;
   bool VisitingInvoke = false;
+  int BaseState;
 };
 
 } // end anonymous namespace
 
 InvokeStateChangeIterator &InvokeStateChangeIterator::scan() {
   bool IsNewBlock = false;
   for (; MFI != MFE; ++MFI, IsNewBlock = true) {
     if (IsNewBlock)
       MBBI = MFI->begin();
     for (auto MBBE = MFI->end(); MBBI != MBBE; ++MBBI) {
       const MachineInstr &MI = *MBBI;
-      if (!VisitingInvoke && LastStateChange.NewState != NullState &&
+      if (!VisitingInvoke && LastStateChange.NewState != BaseState &&
           MI.isCall() && !EHStreamer::callToNoUnwindFunction(&MI)) {
         // Indicate a change of state to the null state.  We don't have
         // start/end EH labels handy but the caller won't expect them for
         // null state regions.
         LastStateChange.PreviousEndLabel = CurrentEndLabel;
         LastStateChange.NewStartLabel = nullptr;
-        LastStateChange.NewState = NullState;
+        LastStateChange.NewState = BaseState;
         CurrentEndLabel = nullptr;
         // Don't re-visit this instr on the next scan
         ++MBBI;
         return *this;
       }
 
       // All other state changes are at EH labels before/after invokes.
       if (!MI.isEHLabel())
         continue;
       MCSymbol *Label = MI.getOperand(0).getMCSymbol();
       if (Label == CurrentEndLabel) {
         VisitingInvoke = false;
         continue;
       }
-      auto InvokeMapIter = EHInfo.InvokeToStateMap.find(Label);
+      auto InvokeMapIter = EHInfo.LabelToStateMap.find(Label);
       // Ignore EH labels that aren't the ones inserted before an invoke
-      if (InvokeMapIter == EHInfo.InvokeToStateMap.end())
+      if (InvokeMapIter == EHInfo.LabelToStateMap.end())
         continue;
       auto &StateAndEnd = InvokeMapIter->second;
       int NewState = StateAndEnd.first;
-      // Ignore EH labels explicitly annotated with the null state (which
-      // can happen for invokes that unwind to a chain of endpads the last
-      // of which unwinds to caller).  We'll see the subsequent invoke and
-      // report a transition to the null state same as we do for calls.
-      if (NewState == NullState)
-        continue;
       // Keep track of the fact that we're between EH start/end labels so
       // we know not to treat the inoke we'll see as unwinding to caller.
       VisitingInvoke = true;
       if (NewState == LastStateChange.NewState) {
         // The state isn't actually changing here.  Record the new end and
         // keep going.
         CurrentEndLabel = StateAndEnd.second;
         continue;
       }
       // Found a state change to report
       LastStateChange.PreviousEndLabel = CurrentEndLabel;
       LastStateChange.NewStartLabel = Label;
       LastStateChange.NewState = NewState;
       // Start keeping track of the new current end
       CurrentEndLabel = StateAndEnd.second;
       // Don't re-visit this instr on the next scan
       ++MBBI;
       return *this;
     }
   }
   // Iteration hit the end of the block range.
-  if (LastStateChange.NewState != NullState) {
+  if (LastStateChange.NewState != BaseState) {
     // Report the end of the last new state
     LastStateChange.PreviousEndLabel = CurrentEndLabel;
     LastStateChange.NewStartLabel = nullptr;
-    LastStateChange.NewState = NullState;
+    LastStateChange.NewState = BaseState;
     // Leave CurrentEndLabel non-null to distinguish this state from end.
     assert(CurrentEndLabel != nullptr);
     return *this;
   }
   // We've reported all state changes and hit the end state.
   CurrentEndLabel = nullptr;
   return *this;
 }
for (auto &IPStatePair : IPToStateTable) {
       OS.EmitIntValue(IPStatePair.second, 4); // State
     }
   }
 }
 
 void WinException::computeIP2StateTable(
     const MachineFunction *MF, const WinEHFuncInfo &FuncInfo,
     SmallVectorImpl<std::pair<const MCExpr *, int>> &IPToStateTable) {
-  // Indicate that all calls from the prologue to the first invoke unwind to
-  // caller. We handle this as a special case since other ranges starting at end
-  // labels need to use LtmpN+1.
-  MCSymbol *StartLabel = Asm->getFunctionBegin();
+
+  for (MachineFunction::const_iterator FuncletStart = MF->begin(),
+                                       FuncletEnd = MF->begin(),
+                                       End = MF->end();
+       FuncletStart != End; FuncletStart = FuncletEnd) {
+    // Find the end of the funclet
+    while (++FuncletEnd != End) {
+      if (FuncletEnd->isEHFuncletEntry()) {
+        break;
+      }
+    }
+
+    // Don't emit ip2state entries for cleanup funclets. Any interesting
+    // exceptional actions in cleanups must be handled in a separate IR
+    // function.
+    if (FuncletStart->isCleanupFuncletEntry())
+      continue;
+
+    MCSymbol *StartLabel;
+    int BaseState;
+    if (FuncletStart == MF->begin()) {
+      BaseState = NullState;
+      StartLabel = Asm->getFunctionBegin();
+    } else {
+      auto *FuncletPad =
+          cast<FuncletPadInst>(FuncletStart->getBasicBlock()->getFirstNonPHI());
+      assert(FuncInfo.FuncletBaseStateMap.count(FuncletPad) != 0);
+      BaseState = FuncInfo.FuncletBaseStateMap.find(FuncletPad)->second;
+      StartLabel = getMCSymbolForMBB(Asm, &*FuncletStart);
+    }
     assert(StartLabel && "need local function start label");
-  IPToStateTable.push_back(std::make_pair(create32bitRef(StartLabel), -1));
+    IPToStateTable.push_back(
+        std::make_pair(create32bitRef(StartLabel), BaseState));
 
-  // FIXME: Do we need to emit entries for funclet base states?
-  for (const auto &StateChange :
-       InvokeStateChangeIterator::range(FuncInfo, *MF)) {
-    // Compute the label to report as the start of this entry; use the EH start
-    // label for the invoke if we have one, otherwise (this is a call which may
-    // unwind to our caller and does not have an EH start label, so) use the
-    // previous end label.
+    for (const auto &StateChange : InvokeStateChangeIterator::range(
+             FuncInfo, FuncletStart, FuncletEnd, BaseState)) {
+      // Compute the label to report as the start of this entry; use the EH
+      // start label for the invoke if we have one, otherwise (this is a call
+      // which may unwind to our caller and does not have an EH start label, so)
+      // use the previous end label.
       const MCSymbol *ChangeLabel = StateChange.NewStartLabel;
       if (!ChangeLabel)
         ChangeLabel = StateChange.PreviousEndLabel;
       // Emit an entry indicating that PCs after 'Label' have this EH state.
       IPToStateTable.push_back(
           std::make_pair(getLabelPlusOne(ChangeLabel), StateChange.NewState));
+      // FIXME: assert that NewState is between CatchLow and CatchHigh.
+    }
   }
 }
 
 void WinException::emitEHRegistrationOffsetLabel(const WinEHFuncInfo &FuncInfo,
                                                  StringRef FLinkageName) {
   // Outlined helpers called by the EH runtime need to know the offset of the EH
   // registration in order to recover the parent frame pointer. Now that we know
   // we've code generated the parent, we can emit the label assignment that

llvm/trunk/lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp

if (BB->isEHPad()) {
       // If this is a non-landingpad EH pad, mark this function as using
       // funclets.
       // FIXME: SEH catchpads do not create funclets, so we could avoid setting
       // this in such cases in order to improve frame layout.
       if (!isa<LandingPadInst>(I)) {
         MMI.setHasEHFunclets(true);
         MF->getFrameInfo()->setHasOpaqueSPAdjustment(true);
       }
-      if (isa<CatchEndPadInst>(I) || isa<CleanupEndPadInst>(I)) {
+      if (isa<CatchSwitchInst>(I)) {
         assert(&*BB->begin() == I &&
                "WinEHPrepare failed to remove PHIs from imaginary BBs");
         continue;
       }
-      if (isa<CatchPadInst>(I) || isa<CleanupPadInst>(I))
+      if (isa<FuncletPadInst>(I))
         assert(&*BB->begin() == I && "WinEHPrepare failed to demote PHIs");
     }
 
     MachineBasicBlock *MBB = mf.CreateMachineBasicBlock(&*BB);
     MBBMap[&*BB] = MBB;
     MF->push_back(MBB);
 
     // Transfer the address-taken flag. This is necessary because there could

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

lowerInvokable(TargetLowering::CallLoweringInfo &CLI,
                  const BasicBlock *EHPadBB = nullptr);
 
   // Terminator instructions.
   void visitRet(const ReturnInst &I);
   void visitBr(const BranchInst &I);
   void visitSwitch(const SwitchInst &I);
   void visitIndirectBr(const IndirectBrInst &I);
   void visitUnreachable(const UnreachableInst &I);
-  void visitCleanupEndPad(const CleanupEndPadInst &I);
   void visitCleanupRet(const CleanupReturnInst &I);
-  void visitCatchEndPad(const CatchEndPadInst &I);
+  void visitCatchSwitch(const CatchSwitchInst &I);
   void visitCatchRet(const CatchReturnInst &I);
   void visitCatchPad(const CatchPadInst &I);
   void visitTerminatePad(const TerminatePadInst &TPI);
   void visitCleanupPad(const CleanupPadInst &CPI);
 
   BranchProbability getEdgeProbability(const MachineBasicBlock *Src,
                                        const MachineBasicBlock *Dst) const;
   void addSuccessorWithProb(

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

void SelectionDAGBuilder::visitCatchPad(const CatchPadInst &I) {
   auto Pers = classifyEHPersonality(FuncInfo.Fn->getPersonalityFn());
   bool IsMSVCCXX = Pers == EHPersonality::MSVC_CXX;
   bool IsCoreCLR = Pers == EHPersonality::CoreCLR;
   MachineBasicBlock *CatchPadMBB = FuncInfo.MBB;
   // In MSVC C++ and CoreCLR, catchblocks are funclets and need prologues.
   if (IsMSVCCXX || IsCoreCLR)
     CatchPadMBB->setIsEHFuncletEntry();
 
-  MachineBasicBlock *NormalDestMBB = FuncInfo.MBBMap[I.getNormalDest()];
-
-  // Update machine-CFG edge.
-  FuncInfo.MBB->addSuccessor(NormalDestMBB);
-
-  SDValue Chain =
-      DAG.getNode(ISD::CATCHPAD, getCurSDLoc(), MVT::Other, getControlRoot());
-
-  // If this is not a fall-through branch or optimizations are switched off,
-  // emit the branch.
-  if (NormalDestMBB != NextBlock(CatchPadMBB) ||
-      TM.getOptLevel() == CodeGenOpt::None)
-    Chain = DAG.getNode(ISD::BR, getCurSDLoc(), MVT::Other, Chain,
-                        DAG.getBasicBlock(NormalDestMBB));
-  DAG.setRoot(Chain);
+  DAG.setRoot(DAG.getNode(ISD::CATCHPAD, getCurSDLoc(), MVT::Other, getControlRoot()));
 }
 
 void SelectionDAGBuilder::visitCatchRet(const CatchReturnInst &I) {
   // Update machine-CFG edge.
   MachineBasicBlock *TargetMBB = FuncInfo.MBBMap[I.getSuccessor()];
   FuncInfo.MBB->addSuccessor(TargetMBB);
 
   auto Pers = classifyEHPersonality(FuncInfo.Fn->getPersonalityFn());
void SelectionDAGBuilder::visitCatchRet(const CatchReturnInst &I) {
 
   // Create the terminator node.
   SDValue Ret = DAG.getNode(ISD::CATCHRET, getCurSDLoc(), MVT::Other,
                             getControlRoot(), DAG.getBasicBlock(TargetMBB),
                             DAG.getBasicBlock(SuccessorColorMBB));
   DAG.setRoot(Ret);
 }
 
-void SelectionDAGBuilder::visitCatchEndPad(const CatchEndPadInst &I) {
-  llvm_unreachable("should never codegen catchendpads");
-}
-
 void SelectionDAGBuilder::visitCleanupPad(const CleanupPadInst &CPI) {
   // Don't emit any special code for the cleanuppad instruction. It just marks
   // the start of a funclet.
   FuncInfo.MBB->setIsEHFuncletEntry();
   FuncInfo.MBB->setIsCleanupFuncletEntry();
 }
 
 /// When an invoke or a cleanupret unwinds to the next EH pad, there are
 /// many places it could ultimately go. In the IR, we have a single unwind
 /// destination, but in the machine CFG, we enumerate all the possible blocks.
-/// This function skips over imaginary basic blocks that hold catchpad,
-/// terminatepad, or catchendpad instructions, and finds all the "real" machine
+/// This function skips over imaginary basic blocks that hold catchswitch or
+/// terminatepad instructions, and finds all the "real" machine
 /// basic block destinations. As those destinations may not be successors of
 /// EHPadBB, here we also calculate the edge probability to those destinations.
 /// The passed-in Prob is the edge probability to EHPadBB.
 static void findUnwindDestinations(
     FunctionLoweringInfo &FuncInfo, const BasicBlock *EHPadBB,
     BranchProbability Prob,
     SmallVectorImpl<std::pair<MachineBasicBlock *, BranchProbability>>
         &UnwindDests) {
if (isa<LandingPadInst>(Pad)) {
       UnwindDests.emplace_back(FuncInfo.MBBMap[EHPadBB], Prob);
       break;
     } else if (isa<CleanupPadInst>(Pad)) {
       // Stop on cleanup pads. Cleanups are always funclet entries for all known
       // personalities.
       UnwindDests.emplace_back(FuncInfo.MBBMap[EHPadBB], Prob);
       UnwindDests.back().first->setIsEHFuncletEntry();
       break;
-    } else if (const auto *CPI = dyn_cast<CatchPadInst>(Pad)) {
-      // Add the catchpad handler to the possible destinations.
-      UnwindDests.emplace_back(FuncInfo.MBBMap[EHPadBB], Prob);
-      // In MSVC C++, catchblocks are funclets and need prologues.
+    } else if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(Pad)) {
+      // Add the catchpad handlers to the possible destinations.
+      for (const BasicBlock *CatchPadBB : CatchSwitch->handlers()) {
+        UnwindDests.emplace_back(FuncInfo.MBBMap[CatchPadBB], Prob);
+        // For MSVC++ and the CLR, catchblocks are funclets and need prologues.
         if (IsMSVCCXX || IsCoreCLR)
           UnwindDests.back().first->setIsEHFuncletEntry();
-      NewEHPadBB = CPI->getUnwindDest();
-    } else if (const auto *CEPI = dyn_cast<CatchEndPadInst>(Pad))
-      NewEHPadBB = CEPI->getUnwindDest();
-    else if (const auto *CEPI = dyn_cast<CleanupEndPadInst>(Pad))
-      NewEHPadBB = CEPI->getUnwindDest();
-    else
+      }
+      NewEHPadBB = CatchSwitch->getUnwindDest();
+    } else {
       continue;
+    }
 
     BranchProbabilityInfo *BPI = FuncInfo.BPI;
     if (BPI && NewEHPadBB)
       Prob *= BPI->getEdgeProbability(EHPadBB, NewEHPadBB);
     EHPadBB = NewEHPadBB;
   }
 }
 
void SelectionDAGBuilder::visitCleanupRet(const CleanupReturnInst &I) {
   FuncInfo.MBB->normalizeSuccProbs();
 
   // Create the terminator node.
   SDValue Ret =
       DAG.getNode(ISD::CLEANUPRET, getCurSDLoc(), MVT::Other, getControlRoot());
   DAG.setRoot(Ret);
 }
 
-void SelectionDAGBuilder::visitCleanupEndPad(const CleanupEndPadInst &I) {
-  report_fatal_error("visitCleanupEndPad not yet implemented!");
-}
-
 void SelectionDAGBuilder::visitTerminatePad(const TerminatePadInst &TPI) {
   report_fatal_error("visitTerminatePad not yet implemented!");
 }
 
+void SelectionDAGBuilder::visitCatchSwitch(const CatchSwitchInst &CSI) {
+  report_fatal_error("visitCatchSwitch not yet implemented!");
+}
+
 void SelectionDAGBuilder::visitRet(const ReturnInst &I) {
   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
   auto &DL = DAG.getDataLayout();
   SDValue Chain = getControlRoot();
   SmallVector<ISD::OutputArg, 8> Outs;
   SmallVector<SDValue, 8> OutVals;
 
   if (!FuncInfo.CanLowerReturn) {
BrAnd = DAG.getNode(ISD::BR, dl, MVT::Other, BrAnd,
                         DAG.getBasicBlock(NextMBB));
 
   DAG.setRoot(BrAnd);
 }
 
 void SelectionDAGBuilder::visitInvoke(const InvokeInst &I) {
   MachineBasicBlock *InvokeMBB = FuncInfo.MBB;
 
-  // Retrieve successors. Look through artificial IR level blocks like catchpads
-  // and catchendpads for successors.
+  // Retrieve successors. Look through artificial IR level blocks like
+  // catchswitch for successors.
   MachineBasicBlock *Return = FuncInfo.MBBMap[I.getSuccessor(0)];
   const BasicBlock *EHPadBB = I.getSuccessor(1);
 
   const Value *Callee(I.getCalledValue());
   const Function *Fn = dyn_cast<Function>(Callee);
   if (isa<InlineAsm>(Callee))
     visitInlineAsm(&I);
   else if (Fn && Fn->isIntrinsic()) {
SelectionDAGBuilder::lowerInvokable(TargetLowering::CallLoweringInfo &CLI,
   if (EHPadBB) {
     // Insert a label at the end of the invoke call to mark the try range.  This
     // can be used to detect deletion of the invoke via the MachineModuleInfo.
     MCSymbol *EndLabel = MMI.getContext().createTempSymbol();
     DAG.setRoot(DAG.getEHLabel(getCurSDLoc(), getRoot(), EndLabel));
 
     // Inform MachineModuleInfo of range.
     if (MMI.hasEHFunclets()) {
+      assert(CLI.CS);
       WinEHFuncInfo *EHInfo = DAG.getMachineFunction().getWinEHFuncInfo();
-      EHInfo->addIPToStateRange(EHPadBB, BeginLabel, EndLabel);
+      EHInfo->addIPToStateRange(cast<InvokeInst>(CLI.CS->getInstruction()),
+                                BeginLabel, EndLabel);
     } else {
       MMI.addInvoke(FuncInfo.MBBMap[EHPadBB], BeginLabel, EndLabel);
     }
   }
 
   return Result;
 }
 

llvm/trunk/lib/CodeGen/TargetLoweringBase.cpp

#include "llvm/IR/Instruction.def"
   switch (static_cast<InstructionOpcodes>(Opcode)) {
   case Ret:            return 0;
   case Br:             return 0;
   case Switch:         return 0;
   case IndirectBr:     return 0;
   case Invoke:         return 0;
   case Resume:         return 0;
   case Unreachable:    return 0;
-  case CleanupEndPad:  return 0;
   case CleanupRet:     return 0;
-  case CatchEndPad:  return 0;
   case CatchRet:       return 0;
-  case CatchPad:     return 0;
-  case TerminatePad: return 0;
-  case CleanupPad:   return 0;
+  case CatchPad:       return 0;
+  case CatchSwitch:    return 0;
+  case TerminatePad:   return 0;
+  case CleanupPad:     return 0;
   case Add:            return ISD::ADD;
   case FAdd:           return ISD::FADD;
   case Sub:            return ISD::SUB;
   case FSub:           return ISD::FSUB;
   case Mul:            return ISD::MUL;
   case FMul:           return ISD::FMUL;
   case UDiv:           return ISD::UDIV;
   case SDiv:           return ISD::SDIV;

llvm/trunk/lib/CodeGen/WinEHPrepare.cpp

 // provided by MSVC. Functions with other personality functions are left alone
 // and may be prepared by other passes. In particular, all supported MSVC
 // personality functions require cleanup code to be outlined, and the C++
 // personality requires catch handler code to be outlined.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/Passes.h"
-#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/MapVector.h"
 #include "llvm/Analysis/CFG.h"
 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/CodeGen/WinEHFuncInfo.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"

 private:
   void insertPHIStores(PHINode *OriginalPHI, AllocaInst *SpillSlot);
   void
   insertPHIStore(BasicBlock *PredBlock, Value *PredVal, AllocaInst *SpillSlot,
                  SmallVectorImpl<std::pair<BasicBlock *, Value *>> &Worklist);
   AllocaInst *insertPHILoads(PHINode *PN, Function &F);
   void replaceUseWithLoad(Value *V, Use &U, AllocaInst *&SpillSlot,
                           DenseMap<BasicBlock *, Value *> &Loads, Function &F);
-  bool prepareExplicitEH(Function &F,
-                         SmallVectorImpl<BasicBlock *> &EntryBlocks);
+  bool prepareExplicitEH(Function &F);
   void replaceTerminatePadWithCleanup(Function &F);
-  void colorFunclets(Function &F, SmallVectorImpl<BasicBlock *> &EntryBlocks);
-  void resolveFuncletAncestry(Function &F,
-                              SmallVectorImpl<BasicBlock *> &EntryBlocks);
-  void resolveFuncletAncestryForPath(
-      Function &F, SmallVectorImpl<BasicBlock *> &FuncletPath,
-      std::map<BasicBlock *, BasicBlock *> &IdentityMap);
-  void makeFuncletEdgeUnreachable(BasicBlock *Parent, BasicBlock *Child);
-  BasicBlock *cloneFuncletForParent(Function &F, BasicBlock *FuncletEntry,
-                                    BasicBlock *Parent);
-  void updateTerminatorsAfterFuncletClone(
-      Function &F, BasicBlock *OrigFunclet, BasicBlock *CloneFunclet,
-      BasicBlock *OrigBlock, BasicBlock *CloneBlock, BasicBlock *CloneParent,
-      ValueToValueMapTy &VMap,
-      std::map<BasicBlock *, BasicBlock *> &Orig2Clone);
+  void colorFunclets(Function &F);
 
   void demotePHIsOnFunclets(Function &F);
-  void cloneCommonBlocks(Function &F,
-                         SmallVectorImpl<BasicBlock *> &EntryBlocks);
+  void cloneCommonBlocks(Function &F);
   void removeImplausibleTerminators(Function &F);
   void cleanupPreparedFunclets(Function &F);
   void verifyPreparedFunclets(Function &F);
 
   // All fields are reset by runOnFunction.
   EHPersonality Personality = EHPersonality::Unknown;
 
-  std::map<BasicBlock *, SetVector<BasicBlock *>> BlockColors;
-  std::map<BasicBlock *, std::set<BasicBlock *>> FuncletBlocks;
-  std::map<BasicBlock *, std::vector<BasicBlock *>> FuncletChildren;
-  std::map<BasicBlock *, std::vector<BasicBlock *>> FuncletParents;
-
-  // This is a flag that indicates an uncommon situation where we need to
-  // clone funclets has been detected.
-  bool FuncletCloningRequired = false;
-  // When a funclet with multiple parents contains a catchret, the block to
-  // which it returns will be cloned so that there is a copy in each parent
-  // but one of the copies will not be properly linked to the catchret and
-  // in most cases will have no predecessors.  This double map allows us
-  // to find these cloned blocks when we clone the child funclet.
-  std::map<BasicBlock *, std::map<BasicBlock *, BasicBlock*>> EstrangedBlocks;
+  DenseMap<BasicBlock *, ColorVector> BlockColors;
+  MapVector<BasicBlock *, std::vector<BasicBlock *>> FuncletBlocks;
 };
 
 } // end anonymous namespace
 
 char WinEHPrepare::ID = 0;
 INITIALIZE_TM_PASS(WinEHPrepare, "winehprepare", "Prepare Windows exceptions",
                    false, false)
 
 FunctionPass *llvm::createWinEHPass(const TargetMachine *TM) {
   return new WinEHPrepare(TM);
 }
 
-static void findFuncletEntryPoints(Function &Fn,
-                                   SmallVectorImpl<BasicBlock *> &EntryBlocks) {
-  EntryBlocks.push_back(&Fn.getEntryBlock());
-  for (BasicBlock &BB : Fn) {
-    Instruction *First = BB.getFirstNonPHI();
-    if (!First->isEHPad())
-      continue;
-    assert(!isa<LandingPadInst>(First) &&
-           "landingpad cannot be used with funclet EH personality");
-    // Find EH pad blocks that represent funclet start points.
-    if (!isa<CatchEndPadInst>(First) && !isa<CleanupEndPadInst>(First))
-      EntryBlocks.push_back(&BB);
-  }
-}
-
 bool WinEHPrepare::runOnFunction(Function &Fn) {
   if (!Fn.hasPersonalityFn())
     return false;
 
   // Classify the personality to see what kind of preparation we need.
   Personality = classifyEHPersonality(Fn.getPersonalityFn());
 
   // Do nothing if this is not a funclet-based personality.
   if (!isFuncletEHPersonality(Personality))
     return false;
 
-  // Remove unreachable blocks.  It is not valuable to assign them a color and
-  // their existence can trick us into thinking values are alive when they are
-  // not.
-  removeUnreachableBlocks(Fn);
-
-  SmallVector<BasicBlock *, 4> EntryBlocks;
-  findFuncletEntryPoints(Fn, EntryBlocks);
-  return prepareExplicitEH(Fn, EntryBlocks);
+  return prepareExplicitEH(Fn);
 }
 
 bool WinEHPrepare::doFinalization(Module &M) { return false; }
 
 void WinEHPrepare::getAnalysisUsage(AnalysisUsage &AU) const {}
 
 static int addUnwindMapEntry(WinEHFuncInfo &FuncInfo, int ToState,
                              const BasicBlock *BB) {
if (isa<ConstantPointerNull>(CPI->getArgOperand(2)))
       HT.CatchObj.Alloca = nullptr;
     else
       HT.CatchObj.Alloca = cast<AllocaInst>(CPI->getArgOperand(2));
     TBME.HandlerArray.push_back(HT);
   }
   FuncInfo.TryBlockMap.push_back(TBME);
 }
 
-static const CatchPadInst *getSingleCatchPadPredecessor(const BasicBlock *BB) {
-  for (const BasicBlock *PredBlock : predecessors(BB))
-    if (auto *CPI = dyn_cast<CatchPadInst>(PredBlock->getFirstNonPHI()))
-      return CPI;
+static BasicBlock *getCleanupRetUnwindDest(const CleanupPadInst *CleanupPad) {
+  for (const User *U : CleanupPad->users())
+    if (const auto *CRI = dyn_cast<CleanupReturnInst>(U))
+      return CRI->getUnwindDest();
   return nullptr;
 }
 
-/// Find all the catchpads that feed directly into the catchendpad. Frontends
-/// using this personality should ensure that each catchendpad and catchpad has
-/// one or zero catchpad predecessors.
-///
-/// The following C++ generates the IR after it:
-///   try {
-///   } catch (A) {
-///   } catch (B) {
-///   }
-///
-/// IR:
-///   %catchpad.A
-///     catchpad [i8* A typeinfo]
-///         to label %catch.A unwind label %catchpad.B
-///   %catchpad.B
-///     catchpad [i8* B typeinfo]
-///         to label %catch.B unwind label %endcatches
-///   %endcatches
-///     catchendblock unwind to caller
-static void
-findCatchPadsForCatchEndPad(const BasicBlock *CatchEndBB,
-                            SmallVectorImpl<const CatchPadInst *> &Handlers) {
-  const CatchPadInst *CPI = getSingleCatchPadPredecessor(CatchEndBB);
-  while (CPI) {
-    Handlers.push_back(CPI);
-    CPI = getSingleCatchPadPredecessor(CPI->getParent());
-  }
-  // We've pushed these back into reverse source order.  Reverse them to get
-  // the list back into source order.
-  std::reverse(Handlers.begin(), Handlers.end());
+static void calculateStateNumbersForInvokes(const Function *Fn,
+                                            WinEHFuncInfo &FuncInfo) {
+  auto *F = const_cast<Function *>(Fn);
+  DenseMap<BasicBlock *, ColorVector> BlockColors = colorEHFunclets(*F);
+  for (BasicBlock &BB : *F) {
+    auto *II = dyn_cast<InvokeInst>(BB.getTerminator());
+    if (!II)
+      continue;
+
+    auto &BBColors = BlockColors[&BB];
+    assert(BBColors.size() == 1 &&
+           "multi-color BB not removed by preparation");
+    BasicBlock *FuncletEntryBB = BBColors.front();
+
+    BasicBlock *FuncletUnwindDest;
+    auto *FuncletPad =
+        dyn_cast<FuncletPadInst>(FuncletEntryBB->getFirstNonPHI());
+    assert(FuncletPad || FuncletEntryBB == &Fn->getEntryBlock());
+    if (!FuncletPad)
+      FuncletUnwindDest = nullptr;
+    else if (auto *CatchPad = dyn_cast<CatchPadInst>(FuncletPad))
+      FuncletUnwindDest = CatchPad->getCatchSwitch()->getUnwindDest();
+    else if (auto *CleanupPad = dyn_cast<CleanupPadInst>(FuncletPad))
+      FuncletUnwindDest = getCleanupRetUnwindDest(CleanupPad);
+    else
+      llvm_unreachable("unexpected funclet pad!");
+
+    BasicBlock *InvokeUnwindDest = II->getUnwindDest();
+    int BaseState = -1;
+    if (FuncletUnwindDest == InvokeUnwindDest) {
+      auto BaseStateI = FuncInfo.FuncletBaseStateMap.find(FuncletPad);
+      if (BaseStateI != FuncInfo.FuncletBaseStateMap.end())
+        BaseState = BaseStateI->second;
+    }
+
+    if (BaseState != -1) {
+      FuncInfo.InvokeStateMap[II] = BaseState;
+    } else {
+      Instruction *PadInst = InvokeUnwindDest->getFirstNonPHI();
+      assert(FuncInfo.EHPadStateMap.count(PadInst) && "EH Pad has no state!");
+      FuncInfo.InvokeStateMap[II] = FuncInfo.EHPadStateMap[PadInst];
+    }
+  }
 }
 
 // Given BB which ends in an unwind edge, return the EHPad that this BB belongs
 // to. If the unwind edge came from an invoke, return null.
-static const BasicBlock *getEHPadFromPredecessor(const BasicBlock *BB) {
+static const BasicBlock *getEHPadFromPredecessor(const BasicBlock *BB,
+                                                 Value *ParentPad) {
   const TerminatorInst *TI = BB->getTerminator();
   if (isa<InvokeInst>(TI))
     return nullptr;
-  if (TI->isEHPad())
+  if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(TI)) {
+    if (CatchSwitch->getParentPad() != ParentPad)
+      return nullptr;
     return BB;
-  return cast<CleanupReturnInst>(TI)->getCleanupPad()->getParent();
+  }
+  assert(!TI->isEHPad() && "unexpected EHPad!");
+  auto *CleanupPad = cast<CleanupReturnInst>(TI)->getCleanupPad();
+  if (CleanupPad->getParentPad() != ParentPad)
+    return nullptr;
+  return CleanupPad->getParent();
 }
 
-static void calculateExplicitCXXStateNumbers(WinEHFuncInfo &FuncInfo,
-                                             const BasicBlock &BB,
-                                             int ParentState) {
-  assert(BB.isEHPad());
-  const Instruction *FirstNonPHI = BB.getFirstNonPHI();
-  // All catchpad instructions will be handled when we process their
-  // respective catchendpad instruction.
-  if (isa<CatchPadInst>(FirstNonPHI))
-    return;
+static void calculateCXXStateNumbers(WinEHFuncInfo &FuncInfo,
+                                     const Instruction *FirstNonPHI,
+  const BasicBlock *BB = FirstNonPHI->getParent();
+  assert(BB->isEHPad() && "not a funclet!");
+
+  if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(FirstNonPHI)) {
+    assert(FuncInfo.EHPadStateMap.count(CatchSwitch) == 0 &&
+           "shouldn't revist catch funclets!");
 
-  if (isa<CatchEndPadInst>(FirstNonPHI)) {
     SmallVector<const CatchPadInst *, 2> Handlers;
-    findCatchPadsForCatchEndPad(&BB, Handlers);
-    const BasicBlock *FirstTryPad = Handlers.front()->getParent();
+    for (const BasicBlock *CatchPadBB : CatchSwitch->handlers()) {
+      auto *CatchPad = cast<CatchPadInst>(CatchPadBB->getFirstNonPHI());
+      Handlers.push_back(CatchPad);
+    }
     int TryLow = addUnwindMapEntry(FuncInfo, ParentState, nullptr);
-    FuncInfo.EHPadStateMap[Handlers.front()] = TryLow;
-    for (const BasicBlock *PredBlock : predecessors(FirstTryPad))
-      if ((PredBlock = getEHPadFromPredecessor(PredBlock)))
-        calculateExplicitCXXStateNumbers(FuncInfo, *PredBlock, TryLow);
+    FuncInfo.EHPadStateMap[CatchSwitch] = TryLow;
+    for (const BasicBlock *PredBlock : predecessors(BB))
+      if ((PredBlock = getEHPadFromPredecessor(PredBlock,
+                                               CatchSwitch->getParentPad())))
+        calculateCXXStateNumbers(FuncInfo, PredBlock->getFirstNonPHI(),
+                                 TryLow);
     int CatchLow = addUnwindMapEntry(FuncInfo, ParentState, nullptr);
 
     // catchpads are separate funclets in C++ EH due to the way rethrow works.
-    // In SEH, they aren't, so no invokes will unwind to the catchendpad.
-    FuncInfo.EHPadStateMap[FirstNonPHI] = CatchLow;
     int TryHigh = CatchLow - 1;
-    for (const BasicBlock *PredBlock : predecessors(&BB))
-      if ((PredBlock = getEHPadFromPredecessor(PredBlock)))
-        calculateExplicitCXXStateNumbers(FuncInfo, *PredBlock, CatchLow);
+    for (const auto *CatchPad : Handlers) {
+      FuncInfo.FuncletBaseStateMap[CatchPad] = CatchLow;
+      for (const User *U : CatchPad->users()) {
+        const auto *UserI = cast<Instruction>(U);
+        if (UserI->isEHPad())
+          calculateCXXStateNumbers(FuncInfo, UserI, CatchLow);
+      }
+    }
     int CatchHigh = FuncInfo.getLastStateNumber();
     addTryBlockMapEntry(FuncInfo, TryLow, TryHigh, CatchHigh, Handlers);
-    DEBUG(dbgs() << "TryLow[" << FirstTryPad->getName() << "]: " << TryLow
-                 << '\n');
-    DEBUG(dbgs() << "TryHigh[" << FirstTryPad->getName() << "]: " << TryHigh
+    DEBUG(dbgs() << "TryLow[" << BB->getName() << "]: " << TryLow << '\n');
+    DEBUG(dbgs() << "TryHigh[" << BB->getName() << "]: " << TryHigh << '\n');
+    DEBUG(dbgs() << "CatchHigh[" << BB->getName() << "]: " << CatchHigh
                  << '\n');
-    DEBUG(dbgs() << "CatchHigh[" << FirstTryPad->getName() << "]: " << CatchHigh
-                 << '\n');
-  } else if (isa<CleanupPadInst>(FirstNonPHI)) {
-    // A cleanup can have multiple exits; don't re-process after the first.
-    if (FuncInfo.EHPadStateMap.count(FirstNonPHI))
+  } else {
+    auto *CleanupPad = cast<CleanupPadInst>(FirstNonPHI);
+
+    // It's possible for a cleanup to be visited twice: it might have multiple
+    // cleanupret instructions.
+    if (FuncInfo.EHPadStateMap.count(CleanupPad))
       return;
-    int CleanupState = addUnwindMapEntry(FuncInfo, ParentState, &BB);
-    FuncInfo.EHPadStateMap[FirstNonPHI] = CleanupState;
+
+    int CleanupState = addUnwindMapEntry(FuncInfo, ParentState, BB);
+    FuncInfo.EHPadStateMap[CleanupPad] = CleanupState;
     DEBUG(dbgs() << "Assigning state #" << CleanupState << " to BB "
-                 << BB.getName() << '\n');
-    for (const BasicBlock *PredBlock : predecessors(&BB))
-      if ((PredBlock = getEHPadFromPredecessor(PredBlock)))
-        calculateExplicitCXXStateNumbers(FuncInfo, *PredBlock, CleanupState);
-  } else if (auto *CEPI = dyn_cast<CleanupEndPadInst>(FirstNonPHI)) {
-    // Propagate ParentState to the cleanuppad in case it doesn't have
-    // any cleanuprets.
-    BasicBlock *CleanupBlock = CEPI->getCleanupPad()->getParent();
-    calculateExplicitCXXStateNumbers(FuncInfo, *CleanupBlock, ParentState);
-    // Anything unwinding through CleanupEndPadInst is in ParentState.
-    FuncInfo.EHPadStateMap[FirstNonPHI] = ParentState;
-    for (const BasicBlock *PredBlock : predecessors(&BB))
-      if ((PredBlock = getEHPadFromPredecessor(PredBlock)))
-        calculateExplicitCXXStateNumbers(FuncInfo, *PredBlock, ParentState);
-  } else if (isa<TerminatePadInst>(FirstNonPHI)) {
-    report_fatal_error("Not yet implemented!");
-  } else {
-    llvm_unreachable("unexpected EH Pad!");
+                 << BB->getName() << '\n');
+    for (const BasicBlock *PredBlock : predecessors(BB)) {
+      if ((PredBlock = getEHPadFromPredecessor(PredBlock,
+                                               CleanupPad->getParentPad()))) {
+        calculateCXXStateNumbers(FuncInfo, PredBlock->getFirstNonPHI(),
+                                 CleanupState);
+      }
+    }
+    for (const User *U : CleanupPad->users()) {
+      const auto *UserI = cast<Instruction>(U);
+      if (UserI->isEHPad())
+        report_fatal_error("Cleanup funclets for the MSVC++ personality cannot "
+                           "contain exceptional actions");
+    }
   }
 }
 
 static int addSEHExcept(WinEHFuncInfo &FuncInfo, int ParentState,
                         const Function *Filter, const BasicBlock *Handler) {
   SEHUnwindMapEntry Entry;
   Entry.ToState = ParentState;
   Entry.IsFinally = false;
static int addSEHFinally(WinEHFuncInfo &FuncInfo, int ParentState,
   Entry.ToState = ParentState;
   Entry.IsFinally = true;
   Entry.Filter = nullptr;
   Entry.Handler = Handler;
   FuncInfo.SEHUnwindMap.push_back(Entry);
   return FuncInfo.SEHUnwindMap.size() - 1;
 }
 
-static void calculateExplicitSEHStateNumbers(WinEHFuncInfo &FuncInfo,
-                                             const BasicBlock &BB,
-                                             int ParentState) {
-  assert(BB.isEHPad());
-  const Instruction *FirstNonPHI = BB.getFirstNonPHI();
-  // All catchpad instructions will be handled when we process their
-  // respective catchendpad instruction.
-  if (isa<CatchPadInst>(FirstNonPHI))
-    return;
+static void calculateSEHStateNumbers(WinEHFuncInfo &FuncInfo,
+                                     const Instruction *FirstNonPHI,
+  const BasicBlock *BB = FirstNonPHI->getParent();
+  assert(BB->isEHPad() && "no a funclet!");
+
+  if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(FirstNonPHI)) {
+    assert(FuncInfo.EHPadStateMap.count(CatchSwitch) == 0 &&
+           "shouldn't revist catch funclets!");
 
-  if (isa<CatchEndPadInst>(FirstNonPHI)) {
     // Extract the filter function and the __except basic block and create a
     // state for them.
-    SmallVector<const CatchPadInst *, 1> Handlers;
-    findCatchPadsForCatchEndPad(&BB, Handlers);
-    assert(Handlers.size() == 1 &&
+    assert(CatchSwitch->getNumHandlers() == 1 &&
            "SEH doesn't have multiple handlers per __try");
-    const CatchPadInst *CPI = Handlers.front();
-    const BasicBlock *CatchPadBB = CPI->getParent();
+    const auto *CatchPad =
+        cast<CatchPadInst>((*CatchSwitch->handler_begin())->getFirstNonPHI());
+    const BasicBlock *CatchPadBB = CatchPad->getParent();
     const Constant *FilterOrNull =
-        cast<Constant>(CPI->getArgOperand(0)->stripPointerCasts());
+        cast<Constant>(CatchPad->getArgOperand(0)->stripPointerCasts());
     const Function *Filter = dyn_cast<Function>(FilterOrNull);
     assert((Filter || FilterOrNull->isNullValue()) &&
            "unexpected filter value");
     int TryState = addSEHExcept(FuncInfo, ParentState, Filter, CatchPadBB);
 
     // Everything in the __try block uses TryState as its parent state.
-    FuncInfo.EHPadStateMap[CPI] = TryState;
+    FuncInfo.EHPadStateMap[CatchSwitch] = TryState;
     DEBUG(dbgs() << "Assigning state #" << TryState << " to BB "
                  << CatchPadBB->getName() << '\n');
-    for (const BasicBlock *PredBlock : predecessors(CatchPadBB))
-      if ((PredBlock = getEHPadFromPredecessor(PredBlock)))
-        calculateExplicitSEHStateNumbers(FuncInfo, *PredBlock, TryState);
+    for (const BasicBlock *PredBlock : predecessors(BB))
+      if ((PredBlock = getEHPadFromPredecessor(PredBlock,
+                                               CatchSwitch->getParentPad())))
+        calculateSEHStateNumbers(FuncInfo, PredBlock->getFirstNonPHI(),
+                                 TryState);
 
     // Everything in the __except block unwinds to ParentState, just like code
     // outside the __try.
-    FuncInfo.EHPadStateMap[FirstNonPHI] = ParentState;
-    DEBUG(dbgs() << "Assigning state #" << ParentState << " to BB "
-                 << BB.getName() << '\n');
-    for (const BasicBlock *PredBlock : predecessors(&BB))
-      if ((PredBlock = getEHPadFromPredecessor(PredBlock)))
-        calculateExplicitSEHStateNumbers(FuncInfo, *PredBlock, ParentState);
-  } else if (isa<CleanupPadInst>(FirstNonPHI)) {
-    // A cleanup can have multiple exits; don't re-process after the first.
-    if (FuncInfo.EHPadStateMap.count(FirstNonPHI))
-      return;
-    int CleanupState = addSEHFinally(FuncInfo, ParentState, &BB);
-    FuncInfo.EHPadStateMap[FirstNonPHI] = CleanupState;
-    DEBUG(dbgs() << "Assigning state #" << CleanupState << " to BB "
-                 << BB.getName() << '\n');
-    for (const BasicBlock *PredBlock : predecessors(&BB))
-      if ((PredBlock = getEHPadFromPredecessor(PredBlock)))
-        calculateExplicitSEHStateNumbers(FuncInfo, *PredBlock, CleanupState);
-  } else if (auto *CEPI = dyn_cast<CleanupEndPadInst>(FirstNonPHI)) {
-    // Propagate ParentState to the cleanuppad in case it doesn't have
-    // any cleanuprets.
-    BasicBlock *CleanupBlock = CEPI->getCleanupPad()->getParent();
-    calculateExplicitSEHStateNumbers(FuncInfo, *CleanupBlock, ParentState);
-    // Anything unwinding through CleanupEndPadInst is in ParentState.
-    FuncInfo.EHPadStateMap[FirstNonPHI] = ParentState;
-    DEBUG(dbgs() << "Assigning state #" << ParentState << " to BB "
-                 << BB.getName() << '\n');
-    for (const BasicBlock *PredBlock : predecessors(&BB))
-      if ((PredBlock = getEHPadFromPredecessor(PredBlock)))
-        calculateExplicitSEHStateNumbers(FuncInfo, *PredBlock, ParentState);
-  } else if (isa<TerminatePadInst>(FirstNonPHI)) {
-    report_fatal_error("Not yet implemented!");
-  } else {
-    llvm_unreachable("unexpected EH Pad!");
+    for (const User *U : CatchPad->users()) {
+      const auto *UserI = cast<Instruction>(U);
+      if (UserI->isEHPad()) {
+        calculateSEHStateNumbers(FuncInfo, UserI, ParentState);
       }
     }
+  } else {
+    auto *CleanupPad = cast<CleanupPadInst>(FirstNonPHI);
 
-/// Check if the EH Pad unwinds to caller.  Cleanups are a little bit of a
-/// special case because we have to look at the cleanupret instruction that uses
-/// the cleanuppad.
-static bool doesEHPadUnwindToCaller(const Instruction *EHPad) {
-  auto *CPI = dyn_cast<CleanupPadInst>(EHPad);
-  if (!CPI)
-    return EHPad->mayThrow();
+    // It's possible for a cleanup to be visited twice: it might have multiple
+    // cleanupret instructions.
+    if (FuncInfo.EHPadStateMap.count(CleanupPad))
+      return;
 
-  // This cleanup does not return or unwind, so we say it unwinds to caller.
-  if (CPI->use_empty())
-    return true;
+    int CleanupState = addSEHFinally(FuncInfo, ParentState, BB);
+    FuncInfo.EHPadStateMap[CleanupPad] = CleanupState;
+    DEBUG(dbgs() << "Assigning state #" << CleanupState << " to BB "
+                 << BB->getName() << '\n');
+    for (const BasicBlock *PredBlock : predecessors(BB))
+      if ((PredBlock =
+               getEHPadFromPredecessor(PredBlock, CleanupPad->getParentPad())))
+        calculateSEHStateNumbers(FuncInfo, PredBlock->getFirstNonPHI(),
+                                 CleanupState);
+    for (const User *U : CleanupPad->users()) {
+      const auto *UserI = cast<Instruction>(U);
+      if (UserI->isEHPad())
+        report_fatal_error("Cleanup funclets for the SEH personality cannot "
+                           "contain exceptional actions");
+    }
+  }
+}
 
-  const Instruction *User = CPI->user_back();
-  if (auto *CRI = dyn_cast<CleanupReturnInst>(User))
-    return CRI->unwindsToCaller();
-  return cast<CleanupEndPadInst>(User)->unwindsToCaller();
+static bool isTopLevelPadForMSVC(const Instruction *EHPad) {
+  if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(EHPad))
+    return isa<ConstantTokenNone>(CatchSwitch->getParentPad()) &&
+           CatchSwitch->unwindsToCaller();
+  if (auto *CleanupPad = dyn_cast<CleanupPadInst>(EHPad))
+    return isa<ConstantTokenNone>(CleanupPad->getParentPad()) &&
+           getCleanupRetUnwindDest(CleanupPad) == nullptr;
+  if (isa<CatchPadInst>(EHPad))
+    return false;
+  llvm_unreachable("unexpected EHPad!");
 }
 
 void llvm::calculateSEHStateNumbers(const Function *Fn,
                                     WinEHFuncInfo &FuncInfo) {
   // Don't compute state numbers twice.
   if (!FuncInfo.SEHUnwindMap.empty())
     return;
 
   for (const BasicBlock &BB : *Fn) {
-    if (!BB.isEHPad() || !doesEHPadUnwindToCaller(BB.getFirstNonPHI()))
+    if (!BB.isEHPad())
       continue;
-    calculateExplicitSEHStateNumbers(FuncInfo, BB, -1);
+    const Instruction *FirstNonPHI = BB.getFirstNonPHI();
+    if (!isTopLevelPadForMSVC(FirstNonPHI))
+      continue;
+    ::calculateSEHStateNumbers(FuncInfo, FirstNonPHI, -1);
   }
+
+  calculateStateNumbersForInvokes(Fn, FuncInfo);
 }
 
 void llvm::calculateWinCXXEHStateNumbers(const Function *Fn,
                                          WinEHFuncInfo &FuncInfo) {
   // Return if it's already been done.
   if (!FuncInfo.EHPadStateMap.empty())
     return;
 
   for (const BasicBlock &BB : *Fn) {
     if (!BB.isEHPad())
       continue;
-    if (BB.isLandingPad())
-      report_fatal_error("MSVC C++ EH cannot use landingpads");
     const Instruction *FirstNonPHI = BB.getFirstNonPHI();
-    if (!doesEHPadUnwindToCaller(FirstNonPHI))
+    if (!isTopLevelPadForMSVC(FirstNonPHI))
       continue;
-    calculateExplicitCXXStateNumbers(FuncInfo, BB, -1);
+    calculateCXXStateNumbers(FuncInfo, FirstNonPHI, -1);
   }
+
+  calculateStateNumbersForInvokes(Fn, FuncInfo);
 }
 
 static int addClrEHHandler(WinEHFuncInfo &FuncInfo, int ParentState,
                            ClrHandlerType HandlerType, uint32_t TypeToken,
                            const BasicBlock *Handler) {
   ClrEHUnwindMapEntry Entry;
   Entry.Parent = ParentState;
   Entry.Handler = Handler;
void llvm::calculateClrEHStateNumbers(const Function *Fn,
   // Each pad needs to be able to refer to its parent, so scan the function
   // looking for top-level handlers and seed the worklist with them.
   for (const BasicBlock &BB : *Fn) {
     if (!BB.isEHPad())
       continue;
     if (BB.isLandingPad())
       report_fatal_error("CoreCLR EH cannot use landingpads");
     const Instruction *FirstNonPHI = BB.getFirstNonPHI();
-    if (!doesEHPadUnwindToCaller(FirstNonPHI))
+    if (!isTopLevelPadForMSVC(FirstNonPHI))
       continue;
     // queue this with sentinel parent state -1 to mean unwind to caller.
     Worklist.emplace_back(FirstNonPHI, -1);
   }
 
   while (!Worklist.empty()) {
     const Instruction *Pad;
     int ParentState;
     std::tie(Pad, ParentState) = Worklist.pop_back_val();
 
+    Value *ParentPad;
     int PredState;
-    if (const CleanupEndPadInst *EndPad = dyn_cast<CleanupEndPadInst>(Pad)) {
-      FuncInfo.EHPadStateMap[EndPad] = ParentState;
-      // Queue the cleanuppad, in case it doesn't have a cleanupret.
-      Worklist.emplace_back(EndPad->getCleanupPad(), ParentState);
-      // Preds of the endpad should get the parent state.
-      PredState = ParentState;
-    } else if (const CleanupPadInst *Cleanup = dyn_cast<CleanupPadInst>(Pad)) {
+    if (const CleanupPadInst *Cleanup = dyn_cast<CleanupPadInst>(Pad)) {
       // A cleanup can have multiple exits; don't re-process after the first.
-      if (FuncInfo.EHPadStateMap.count(Pad))
+      if (FuncInfo.EHPadStateMap.count(Cleanup))
         continue;
       // CoreCLR personality uses arity to distinguish faults from finallies.
       const BasicBlock *PadBlock = Cleanup->getParent();
       ClrHandlerType HandlerType =
           (Cleanup->getNumOperands() ? ClrHandlerType::Fault
                                      : ClrHandlerType::Finally);
       int NewState =
           addClrEHHandler(FuncInfo, ParentState, HandlerType, 0, PadBlock);
       FuncInfo.EHPadStateMap[Cleanup] = NewState;
       // Propagate the new state to all preds of the cleanup
+      ParentPad = Cleanup->getParentPad();
       PredState = NewState;
-    } else if (const CatchEndPadInst *EndPad = dyn_cast<CatchEndPadInst>(Pad)) {
-      FuncInfo.EHPadStateMap[EndPad] = ParentState;
-      // Preds of the endpad should get the parent state.
-      PredState = ParentState;
-    } else if (const CatchPadInst *Catch = dyn_cast<CatchPadInst>(Pad)) {
+    } else if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(Pad)) {
+      SmallVector<const CatchPadInst *, 1> Handlers;
+      for (const BasicBlock *CatchPadBB : CatchSwitch->handlers()) {
+        const auto *Catch = cast<CatchPadInst>(CatchPadBB->getFirstNonPHI());
+        Handlers.push_back(Catch);
+      }
+      FuncInfo.EHPadStateMap[CatchSwitch] = ParentState;
+      int NewState = ParentState;
+      for (auto HandlerI = Handlers.rbegin(), HandlerE = Handlers.rend();
+           HandlerI != HandlerE; ++HandlerI) {
+        const CatchPadInst *Catch = *HandlerI;
         const BasicBlock *PadBlock = Catch->getParent();
         uint32_t TypeToken = static_cast<uint32_t>(
             cast<ConstantInt>(Catch->getArgOperand(0))->getZExtValue());
-      int NewState = addClrEHHandler(FuncInfo, ParentState,
-                                     ClrHandlerType::Catch, TypeToken, PadBlock);
+        NewState = addClrEHHandler(FuncInfo, NewState, ClrHandlerType::Catch,
+                                   TypeToken, PadBlock);
         FuncInfo.EHPadStateMap[Catch] = NewState;
-      // Preds of the catch get its state
+      }
+      for (const auto *CatchPad : Handlers) {
+        for (const User *U : CatchPad->users()) {
+          const auto *UserI = cast<Instruction>(U);
+          if (UserI->isEHPad())
+            Worklist.emplace_back(UserI, ParentState);
+        }
+      }
       PredState = NewState;
+      ParentPad = CatchSwitch->getParentPad();
     } else {
       llvm_unreachable("Unexpected EH pad");
     }
 
     // Queue all predecessors with the given state
     for (const BasicBlock *Pred : predecessors(Pad->getParent())) {
-      if ((Pred = getEHPadFromPredecessor(Pred)))
+      if ((Pred = getEHPadFromPredecessor(Pred, ParentPad)))
         Worklist.emplace_back(Pred->getFirstNonPHI(), PredState);
     }
   }
+
+  calculateStateNumbersForInvokes(Fn, FuncInfo);
 }
 
 void WinEHPrepare::replaceTerminatePadWithCleanup(Function &F) {
   if (Personality != EHPersonality::MSVC_CXX)
     return;
   for (BasicBlock &BB : F) {
     Instruction *First = BB.getFirstNonPHI();
     auto *TPI = dyn_cast<TerminatePadInst>(First);
     if (!TPI)
       continue;
 
     if (TPI->getNumArgOperands() != 1)
       report_fatal_error(
           "Expected a unary terminatepad for MSVC C++ personalities!");
 
     auto *TerminateFn = dyn_cast<Function>(TPI->getArgOperand(0));
     if (!TerminateFn)
       report_fatal_error("Function operand expected in terminatepad for MSVC "
                          "C++ personalities!");
 
     // Insert the cleanuppad instruction.
-    auto *CPI = CleanupPadInst::Create(
-        BB.getContext(), {}, Twine("terminatepad.for.", BB.getName()), &BB);
+    auto *CPI =
+        CleanupPadInst::Create(TPI->getParentPad(), {},
+                               Twine("terminatepad.for.", BB.getName()), &BB);
 
     // Insert the call to the terminate instruction.
     auto *CallTerminate = CallInst::Create(TerminateFn, {}, &BB);
     CallTerminate->setDoesNotThrow();
     CallTerminate->setDoesNotReturn();
     CallTerminate->setCallingConv(TerminateFn->getCallingConv());
 
     // Insert a new terminator for the cleanuppad using the same successor as
     // the terminatepad.
     CleanupReturnInst::Create(CPI, TPI->getUnwindDest(), &BB);
 
     // Let's remove the terminatepad now that we've inserted the new
     // instructions.
     TPI->eraseFromParent();
   }
 }
 
-static void
-colorFunclets(Function &F, SmallVectorImpl<BasicBlock *> &EntryBlocks,
-              std::map<BasicBlock *, SetVector<BasicBlock *>> &BlockColors,
-              std::map<BasicBlock *, std::set<BasicBlock *>> &FuncletBlocks) {
-  SmallVector<std::pair<BasicBlock *, BasicBlock *>, 16> Worklist;
-  BasicBlock *EntryBlock = &F.getEntryBlock();
-
-  // Build up the color map, which maps each block to its set of 'colors'.
-  // For any block B, the "colors" of B are the set of funclets F (possibly
-  // including a root "funclet" representing the main function), such that
-  // F will need to directly contain B or a copy of B (where the term "directly
-  // contain" is used to distinguish from being "transitively contained" in
-  // a nested funclet).
-  // Use a CFG walk driven by a worklist of (block, color) pairs.  The "color"
-  // sets attached during this processing to a block which is the entry of some
-  // funclet F is actually the set of F's parents -- i.e. the union of colors
-  // of all predecessors of F's entry.  For all other blocks, the color sets
-  // are as defined above.  A post-pass fixes up the block color map to reflect
-  // the same sense of "color" for funclet entries as for other blocks.
-
-  DEBUG_WITH_TYPE("winehprepare-coloring", dbgs() << "\nColoring funclets for "
-                                                  << F.getName() << "\n");
-
-  Worklist.push_back({EntryBlock, EntryBlock});
-
-  while (!Worklist.empty()) {
-    BasicBlock *Visiting;
-    BasicBlock *Color;
-    std::tie(Visiting, Color) = Worklist.pop_back_val();
-    DEBUG_WITH_TYPE("winehprepare-coloring",
-                    dbgs() << "Visiting " << Visiting->getName() << ", "
-                           << Color->getName() << "\n");
-    Instruction *VisitingHead = Visiting->getFirstNonPHI();
-    if (VisitingHead->isEHPad() && !isa<CatchEndPadInst>(VisitingHead) &&
-        !isa<CleanupEndPadInst>(VisitingHead)) {
-      // Mark this as a funclet head as a member of itself.
-      FuncletBlocks[Visiting].insert(Visiting);
-      // Queue exits (i.e. successors of rets/endpads) with the parent color.
-      // Skip any exits that are catchendpads, since the parent color must then
-      // represent one of the catches chained to that catchendpad, but the
-      // catchendpad should get the color of the common parent of all its
-      // chained catches (i.e. the grandparent color of the current pad).
-      // We don't need to worry abou catchendpads going unvisited, since the
-      // catches chained to them must have unwind edges to them by which we will
-      // visit them.
-      for (User *U : VisitingHead->users()) {
-        if (auto *Exit = dyn_cast<TerminatorInst>(U)) {
-          for (BasicBlock *Succ : successors(Exit->getParent()))
-            if (!isa<CatchEndPadInst>(*Succ->getFirstNonPHI()))
-              if (BlockColors[Succ].insert(Color)) {
-                DEBUG_WITH_TYPE("winehprepare-coloring",
-                                dbgs() << "  Assigned color \'"
-                                       << Color->getName() << "\' to block \'"
-                                       << Succ->getName() << "\'.\n");
-                Worklist.push_back({Succ, Color});
-              }
-        }
-      }
-      // Handle CatchPad specially since its successors need different colors.
-      if (CatchPadInst *CatchPad = dyn_cast<CatchPadInst>(VisitingHead)) {
-        // Visit the normal successor with the color of the new EH pad, and
-        // visit the unwind successor with the color of the parent.
-        BasicBlock *NormalSucc = CatchPad->getNormalDest();
-        if (BlockColors[NormalSucc].insert(Visiting)) {
-          DEBUG_WITH_TYPE("winehprepare-coloring",
-                          dbgs() << "  Assigned color \'" << Visiting->getName()
-                                 << "\' to block \'" << NormalSucc->getName()
-                                 << "\'.\n");
-          Worklist.push_back({NormalSucc, Visiting});
-        }
-        BasicBlock *UnwindSucc = CatchPad->getUnwindDest();
-        if (BlockColors[UnwindSucc].insert(Color)) {
-          DEBUG_WITH_TYPE("winehprepare-coloring",
-                          dbgs() << "  Assigned color \'" << Color->getName()
-                                 << "\' to block \'" << UnwindSucc->getName()
-                                 << "\'.\n");
-          Worklist.push_back({UnwindSucc, Color});
-        }
-        continue;
-      }
-      // Switch color to the current node, except for terminate pads which
-      // have no bodies and only unwind successors and so need their successors
-      // visited with the color of the parent.
-      if (!isa<TerminatePadInst>(VisitingHead))
-        Color = Visiting;
-    } else {
-      // Note that this is a member of the given color.
-      FuncletBlocks[Color].insert(Visiting);
-    }
-
-    TerminatorInst *Terminator = Visiting->getTerminator();
-    if (isa<CleanupReturnInst>(Terminator) ||
-        isa<CatchReturnInst>(Terminator) ||
-        isa<CleanupEndPadInst>(Terminator)) {
-      // These blocks' successors have already been queued with the parent
-      // color.
-      continue;
-    }
-    for (BasicBlock *Succ : successors(Visiting)) {
-      if (isa<CatchEndPadInst>(Succ->getFirstNonPHI())) {
-        // The catchendpad needs to be visited with the parent's color, not
-        // the current color.  This will happen in the code above that visits
-        // any catchpad unwind successor with the parent color, so we can
-        // safely skip this successor here.
-        continue;
-      }
-      if (BlockColors[Succ].insert(Color)) {
-        DEBUG_WITH_TYPE("winehprepare-coloring",
-                        dbgs() << "  Assigned color \'" << Color->getName()
-                               << "\' to block \'" << Succ->getName()
-                               << "\'.\n");
-        Worklist.push_back({Succ, Color});
-      }
-    }
-  }
-}
-
-static BasicBlock *getEndPadForCatch(CatchPadInst *Catch) {
-  // The catch may have sibling catches.  Follow the unwind chain until we get
-  // to the catchendpad.
-  BasicBlock *NextUnwindDest = Catch->getUnwindDest();
-  auto *UnwindTerminator = NextUnwindDest->getTerminator();
-  while (auto *NextCatch = dyn_cast<CatchPadInst>(UnwindTerminator)) {
-    NextUnwindDest = NextCatch->getUnwindDest();
-    UnwindTerminator = NextUnwindDest->getTerminator();
-  }
-  // The last catch in the chain must unwind to a catchendpad.
-  assert(isa<CatchEndPadInst>(UnwindTerminator));
-  return NextUnwindDest;
-}
-
-static void updateClonedEHPadUnwindToParent(
-    BasicBlock *UnwindDest, BasicBlock *OrigBlock, BasicBlock *CloneBlock,
-    std::vector<BasicBlock *> &OrigParents, BasicBlock *CloneParent) {
-  auto updateUnwindTerminator = [](BasicBlock *BB) {
-    auto *Terminator = BB->getTerminator();
-    if (isa<CatchEndPadInst>(Terminator) ||
-        isa<CleanupEndPadInst>(Terminator)) {
-      removeUnwindEdge(BB);
-    } else {
-      // If the block we're updating has a cleanupendpad or cleanupret
-      // terminator, we just want to replace that terminator with an
-      // unreachable instruction.
-      assert(isa<CleanupEndPadInst>(Terminator) ||
-             isa<CleanupReturnInst>(Terminator));
-      // Loop over all of the successors, removing the block's entry from any
-      // PHI nodes.
-      for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE; ++SI)
-        (*SI)->removePredecessor(BB);
-      // Remove the terminator and replace it with an unreachable instruction.
-      BB->getTerminator()->eraseFromParent();
-      new UnreachableInst(BB->getContext(), BB);
-    }
-  };
-
-  assert(UnwindDest->isEHPad());
-  // There are many places to which this EH terminator can unwind and each has
-  // slightly different rules for whether or not it fits with the given
-  // location.
-  auto *EHPadInst = UnwindDest->getFirstNonPHI();
-  if (isa<CatchEndPadInst>(EHPadInst)) {
-    auto *CloneParentCatch =
-        dyn_cast<CatchPadInst>(CloneParent->getFirstNonPHI());
-    if (!CloneParentCatch ||
-        getEndPadForCatch(CloneParentCatch) != UnwindDest) {
-      DEBUG_WITH_TYPE(
-          "winehprepare-coloring",
-          dbgs() << "      removing unwind destination of clone block \'"
-                 << CloneBlock->getName() << "\'.\n");
-      updateUnwindTerminator(CloneBlock);
-    }
-    // It's possible that the catch end pad is a legal match for both the clone
-    // and the original, so they must be checked separately.  If the original
-    // funclet will still have multiple parents after the current clone parent
-    // is removed, we'll leave its unwind terminator until later.
-    assert(OrigParents.size() >= 2);
-    if (OrigParents.size() != 2)
-      return;
-
-    // If the original funclet will have a single parent after the clone parent
-    // is removed, check that parent's unwind destination.
-    assert(OrigParents.front() == CloneParent ||
-           OrigParents.back() == CloneParent);
-    BasicBlock *OrigParent;
-    if (OrigParents.front() == CloneParent)
-      OrigParent = OrigParents.back();
-    else
-      OrigParent = OrigParents.front();
-
-    auto *OrigParentCatch =
-        dyn_cast<CatchPadInst>(OrigParent->getFirstNonPHI());
-    if (!OrigParentCatch || getEndPadForCatch(OrigParentCatch) != UnwindDest) {
-      DEBUG_WITH_TYPE(
-          "winehprepare-coloring",
-          dbgs() << "      removing unwind destination of original block \'"
-                 << OrigBlock << "\'.\n");
-      updateUnwindTerminator(OrigBlock);
-    }
-  } else if (auto *CleanupEnd = dyn_cast<CleanupEndPadInst>(EHPadInst)) {
-    // If the EH terminator unwinds to a cleanupendpad, that cleanupendpad
-    // must be ending a cleanuppad of either our clone parent or one
-    // one of the parents of the original funclet.
-    auto *CloneParentCP =
-        dyn_cast<CleanupPadInst>(CloneParent->getFirstNonPHI());
-    auto *EndedCP = CleanupEnd->getCleanupPad();
-    if (EndedCP == CloneParentCP) {
-      // If it is ending the cleanuppad of our cloned parent, then we
-      // want to remove the unwind destination of the EH terminator that
-      // we associated with the original funclet.
-      assert(isa<CatchEndPadInst>(OrigBlock->getFirstNonPHI()));
-      DEBUG_WITH_TYPE(
-          "winehprepare-coloring",
-          dbgs() << "      removing unwind destination of original block \'"
-                 << OrigBlock->getName() << "\'.\n");
-      updateUnwindTerminator(OrigBlock);
-    } else {
-      // If it isn't ending the cleanuppad of our clone parent, then we
-      // want to remove the unwind destination of the EH terminator that
-      // associated with our cloned funclet.
-      assert(isa<CatchEndPadInst>(CloneBlock->getFirstNonPHI()));
-      DEBUG_WITH_TYPE(
-          "winehprepare-coloring",
-          dbgs() << "      removing unwind destination of clone block \'"
-                 << CloneBlock->getName() << "\'.\n");
-      updateUnwindTerminator(CloneBlock);
-    }
-  } else {
-    // If the EH terminator unwinds to a catchpad, cleanuppad or
-    // terminatepad that EH pad must be a sibling of the funclet we're
-    // cloning.  We'll clone it later and update one of the catchendpad
-    // instrunctions that unwinds to it at that time.
-    assert(isa<CatchPadInst>(EHPadInst) || isa<CleanupPadInst>(EHPadInst) ||
-           isa<TerminatePadInst>(EHPadInst));
-  }
-}
-
-// If the terminator is a catchpad, we must also clone the catchendpad to which
-// it unwinds and add this to the clone parent's block list.  The catchendpad
-// unwinds to either its caller, a sibling EH pad, a cleanup end pad in its
-// parent funclet or a catch end pad in its grandparent funclet (which must be
-// coupled with the parent funclet).  If it has no unwind destination
-// (i.e. unwind to caller), there is nothing to be done. If the unwind
-// destination is a sibling EH pad, we will update the terminators later (in
-// resolveFuncletAncestryForPath).  If it unwinds to a cleanup end pad or a
-// catch end pad and this end pad corresponds to the clone parent, we will
-// remove the unwind destination in the original catchendpad. If it unwinds to
-// a cleanup end pad or a catch end pad that does not correspond to the clone
-// parent, we will remove the unwind destination in the cloned catchendpad.
-static void updateCatchTerminators(
-    Function &F, CatchPadInst *OrigCatch, CatchPadInst *CloneCatch,
-    std::vector<BasicBlock *> &OrigParents, BasicBlock *CloneParent,
-    ValueToValueMapTy &VMap,
-    std::map<BasicBlock *, SetVector<BasicBlock *>> &BlockColors,
-    std::map<BasicBlock *, std::set<BasicBlock *>> &FuncletBlocks) {
-  // If we're cloning a catch pad that unwinds to a catchendpad, we also
-  // need to clone the catchendpad.  The coloring algorithm associates
-  // the catchendpad block with the funclet's parent, so we have some work
-  // to do here to figure out whether the original belongs to the clone
-  // parent or one of the original funclets other parents (it might have
-  // more than one at this point).  In either case, we might also need to
-  // remove the unwind edge if the catchendpad doesn't unwind to a block
-  // in the right grandparent funclet.
-  Instruction *I = CloneCatch->getUnwindDest()->getFirstNonPHI();
-  if (auto *CEP = dyn_cast<CatchEndPadInst>(I)) {
-    assert(BlockColors[CEP->getParent()].size() == 1);
-    BasicBlock *CEPFunclet = *(BlockColors[CEP->getParent()].begin());
-    BasicBlock *CEPCloneParent = nullptr;
-    CatchPadInst *PredCatch = nullptr;
-    if (CEPFunclet == CloneParent) {
-      // The catchendpad is in the clone parent, so we need to clone it
-      // and associate the clone with the original funclet's parent.  If
-      // the original funclet had multiple parents, we'll add it to the
-      // first parent that isn't the clone parent.  The logic in
-      // updateClonedEHPadUnwindToParent() will only remove the unwind edge
-      // if there is only one parent other than the clone parent, so we don't
-      // need to verify the ancestry.  The catchendpad will eventually be
-      // cloned into the correct parent and all invalid unwind edges will be
-      // removed.
-      for (auto *Parent : OrigParents) {
-        if (Parent != CloneParent) {
-          CEPCloneParent = Parent;
-          break;
-        }
-      }
-      PredCatch = OrigCatch;
-    } else {
-      CEPCloneParent = CloneParent;
-      PredCatch = CloneCatch;
-    }
-    assert(CEPCloneParent && PredCatch);
-    DEBUG_WITH_TYPE("winehprepare-coloring",
-                    dbgs() << "  Cloning catchendpad \'"
-                           << CEP->getParent()->getName() << "\' for funclet \'"
-                           << CEPCloneParent->getName() << "\'.\n");
-    BasicBlock *ClonedCEP = CloneBasicBlock(
-        CEP->getParent(), VMap, Twine(".from.", CEPCloneParent->getName()));
-    // Insert the clone immediately after the original to ensure determinism
-    // and to keep the same relative ordering of any funclet's blocks.
-    ClonedCEP->insertInto(&F, CEP->getParent()->getNextNode());
-    PredCatch->setUnwindDest(ClonedCEP);
-    FuncletBlocks[CEPCloneParent].insert(ClonedCEP);
-    BlockColors[ClonedCEP].insert(CEPCloneParent);
-    DEBUG_WITH_TYPE("winehprepare-coloring",
-                    dbgs() << "    Assigning color \'"
-                           << CEPCloneParent->getName() << "\' to block \'"
-                           << ClonedCEP->getName() << "\'.\n");
-    auto *ClonedCEPInst = cast<CatchEndPadInst>(ClonedCEP->getTerminator());
-    if (auto *Dest = ClonedCEPInst->getUnwindDest())
-      updateClonedEHPadUnwindToParent(Dest, OrigCatch->getUnwindDest(),
-                                      CloneCatch->getUnwindDest(), OrigParents,
-                                      CloneParent);
-  }
-}
-
-// While we are cloning a funclet because it has multiple parents, we will call
-// this routine to update the terminators for the original and cloned copies
-// of each basic block.  All blocks in the funclet have been clone by this time.
-// OrigBlock and CloneBlock will be identical except for their block label.
-//
-// If the terminator is a catchpad, we must also clone the catchendpad to which
-// it unwinds and in most cases update either the original catchendpad or the
-// clone.  See the updateCatchTerminators() helper routine for details.
-//
-// If the terminator is a catchret its successor is a block in its parent
-// funclet.  If the instruction returns to a block in the parent for which the
-// cloned funclet was created, the terminator in the original block must be
-// replaced by an unreachable instruction.  Otherwise the terminator in the
-// clone block must be replaced by an unreachable instruction.
-//
-// If the terminator is a cleanupret or cleanupendpad it either unwinds to
-// caller or unwinds to a sibling EH pad, a cleanup end pad in its parent
-// funclet or a catch end pad in its grandparent funclet (which must be
-// coupled with the parent funclet).  If it unwinds to caller there is
-// nothing to be done. If the unwind destination is a sibling EH pad, we will
-// update the terminators later (in resolveFuncletAncestryForPath).  If it
-// unwinds to a cleanup end pad or a catch end pad and this end pad corresponds
-// to the clone parent, we will replace the terminator in the original block
-// with an unreachable instruction. If it unwinds to a cleanup end pad or a
-// catch end pad that does not correspond to the clone parent, we will replace
-// the terminator in the clone block with an unreachable instruction.
-//
-// If the terminator is an invoke instruction, we will handle it after all
-// siblings of the current funclet have been cloned.
-void WinEHPrepare::updateTerminatorsAfterFuncletClone(
-    Function &F, BasicBlock *OrigFunclet, BasicBlock *CloneFunclet,
-    BasicBlock *OrigBlock, BasicBlock *CloneBlock, BasicBlock *CloneParent,
-    ValueToValueMapTy &VMap, std::map<BasicBlock *, BasicBlock *> &Orig2Clone) {
-  // If the cloned block doesn't have an exceptional terminator, there is
-  // nothing to be done here.
-  TerminatorInst *CloneTerminator = CloneBlock->getTerminator();
-  if (!CloneTerminator->isExceptional())
-    return;
-
-  if (auto *CloneCatch = dyn_cast<CatchPadInst>(CloneTerminator)) {
-    // A cloned catch pad has a lot of wrinkles, so we'll call a helper function
-    // to update this case.
-    auto *OrigCatch = cast<CatchPadInst>(OrigBlock->getTerminator());
-    updateCatchTerminators(F, OrigCatch, CloneCatch,
-                           FuncletParents[OrigFunclet], CloneParent, VMap,
-                           BlockColors, FuncletBlocks);
-  } else if (auto *CRI = dyn_cast<CatchReturnInst>(CloneTerminator)) {
-    if (FuncletBlocks[CloneParent].count(CRI->getSuccessor())) {
-      BasicBlock *OrigParent;
-      // The original funclet may have more than two parents, but that's OK.
-      // We just need to remap the original catchret to any of the parents.
-      // All of the parents should have an entry in the EstrangedBlocks map
-      // if any of them do.
-      if (FuncletParents[OrigFunclet].front() == CloneParent)
-        OrigParent = FuncletParents[OrigFunclet].back();
-      else
-        OrigParent = FuncletParents[OrigFunclet].front();
-      for (succ_iterator SI = succ_begin(OrigBlock), SE = succ_end(OrigBlock);
-           SI != SE; ++SI)
-        (*SI)->removePredecessor(OrigBlock);
-      BasicBlock *LostBlock = EstrangedBlocks[OrigParent][CRI->getSuccessor()];
-      auto *OrigCatchRet = cast<CatchReturnInst>(OrigBlock->getTerminator());
-      if (LostBlock) {
-        OrigCatchRet->setSuccessor(LostBlock);
-      } else {
-        OrigCatchRet->eraseFromParent();
-        new UnreachableInst(OrigBlock->getContext(), OrigBlock);
-      }
-    } else {
-      for (succ_iterator SI = succ_begin(CloneBlock), SE = succ_end(CloneBlock);
-           SI != SE; ++SI)
-        (*SI)->removePredecessor(CloneBlock);
-      BasicBlock *LostBlock = EstrangedBlocks[CloneParent][CRI->getSuccessor()];
-      if (LostBlock) {
-        CRI->setSuccessor(LostBlock);
-      } else {
-        CRI->eraseFromParent();
-        new UnreachableInst(CloneBlock->getContext(), CloneBlock);
-      }
-    }
-  } else if (isa<CleanupReturnInst>(CloneTerminator) ||
-             isa<CleanupEndPadInst>(CloneTerminator)) {
-    BasicBlock *UnwindDest = nullptr;
-
-    // A cleanup pad can unwind through either a cleanupret or a cleanupendpad
-    // but both are handled the same way.
-    if (auto *CRI = dyn_cast<CleanupReturnInst>(CloneTerminator))
-      UnwindDest = CRI->getUnwindDest();
-    else if (auto *CEI = dyn_cast<CleanupEndPadInst>(CloneTerminator))
-      UnwindDest = CEI->getUnwindDest();
-
-    // If the instruction has no local unwind destination, there is nothing
-    // to be done.
-    if (!UnwindDest)
-      return;
-
-    // The unwind destination may be a sibling EH pad, a catchendpad in
-    // a grandparent funclet (ending a catchpad in the parent) or a cleanup
-    // cleanupendpad in the parent.  Call a helper routine to diagnose this
-    // and remove either the clone or original terminator as needed.
-    updateClonedEHPadUnwindToParent(UnwindDest, OrigBlock, CloneBlock,
-                                    FuncletParents[OrigFunclet], CloneParent);
-  }
-}
-
-// Clones all blocks used by the specified funclet to avoid the funclet having
-// multiple parent funclets.  All terminators in the parent that unwind to the
-// original funclet are remapped to unwind to the clone.  Any terminator in the
-// original funclet which returned to this parent is converted to an unreachable
-// instruction. Likewise, any terminator in the cloned funclet which returns to
-// a parent funclet other than the specified parent is converted to an
-// unreachable instruction.
-BasicBlock *WinEHPrepare::cloneFuncletForParent(Function &F,
-                                                BasicBlock *FuncletEntry,
-                                                BasicBlock *Parent) {
-  std::set<BasicBlock *> &BlocksInFunclet = FuncletBlocks[FuncletEntry];
-
-  DEBUG_WITH_TYPE("winehprepare-coloring",
-                  dbgs() << "Cloning funclet \'" << FuncletEntry->getName()
-                         << "\' for parent \'" << Parent->getName() << "\'.\n");
-
-  std::map<BasicBlock *, BasicBlock *> Orig2Clone;
-  ValueToValueMapTy VMap;
-  for (BasicBlock *BB : BlocksInFunclet) {
-    // Create a new basic block and copy instructions into it.
-    BasicBlock *CBB =
-        CloneBasicBlock(BB, VMap, Twine(".from.", Parent->getName()));
-
-    // Insert the clone immediately after the original to ensure determinism
-    // and to keep the same relative ordering of any funclet's blocks.
-    CBB->insertInto(&F, BB->getNextNode());
-
-    // Add basic block mapping.
-    VMap[BB] = CBB;
-
-    // Record delta operations that we need to perform to our color mappings.
-    Orig2Clone[BB] = CBB;
-  } // end for (BasicBlock *BB : BlocksInFunclet)
-
-  BasicBlock *ClonedFunclet = Orig2Clone[FuncletEntry];
-  assert(ClonedFunclet);
-
-  // Set the coloring for the blocks we just cloned.
-  std::set<BasicBlock *> &ClonedBlocks = FuncletBlocks[ClonedFunclet];
-  for (auto &BBMapping : Orig2Clone) {
-    BasicBlock *NewBlock = BBMapping.second;
-    ClonedBlocks.insert(NewBlock);
-    BlockColors[NewBlock].insert(ClonedFunclet);
-
-    DEBUG_WITH_TYPE("winehprepare-coloring",
-                    dbgs() << "  Assigning color \'" << ClonedFunclet->getName()
-                           << "\' to block \'" << NewBlock->getName()
-                           << "\'.\n");
-
-    // Use the VMap to remap the instructions in this cloned block.
-    for (Instruction &I : *NewBlock)
-      RemapInstruction(&I, VMap, RF_IgnoreMissingEntries);
-  }
-
-  // All the cloned blocks have to be colored in the loop above before we can
-  // update the terminators because doing so can require checking the color of
-  // other blocks in the cloned funclet.
-  for (auto &BBMapping : Orig2Clone) {
-    BasicBlock *OldBlock = BBMapping.first;
-    BasicBlock *NewBlock = BBMapping.second;
-
-    // Update the terminator, if necessary, in both the original block and the
-    // cloned so that the original funclet never returns to a block in the
-    // clone parent and the clone funclet never returns to a block in any other
-    // of the original funclet's parents.
-    updateTerminatorsAfterFuncletClone(F, FuncletEntry, ClonedFunclet, OldBlock,
-                                       NewBlock, Parent, VMap, Orig2Clone);
-
-    // Check to see if the cloned block successor has PHI nodes. If so, we need
-    // to add entries to the PHI nodes for the cloned block now.
-    for (BasicBlock *SuccBB : successors(NewBlock)) {
-      for (Instruction &SuccI : *SuccBB) {
-        auto *SuccPN = dyn_cast<PHINode>(&SuccI);
-        if (!SuccPN)
-          break;
-
-        // Ok, we have a PHI node.  Figure out what the incoming value was for
-        // the OldBlock.
-        int OldBlockIdx = SuccPN->getBasicBlockIndex(OldBlock);
-        if (OldBlockIdx == -1)
-          break;
-        Value *IV = SuccPN->getIncomingValue(OldBlockIdx);
-
-        // Remap the value if necessary.
-        if (auto *Inst = dyn_cast<Instruction>(IV)) {
-          ValueToValueMapTy::iterator I = VMap.find(Inst);
-          if (I != VMap.end())
-            IV = I->second;
-        }
-
-        SuccPN->addIncoming(IV, NewBlock);
-      }
-    }
-  }
+void WinEHPrepare::colorFunclets(Function &F) {
+  BlockColors = colorEHFunclets(F);
 
-  // Erase the clone's parent from the original funclet's parent list.
-  std::vector<BasicBlock *> &Parents = FuncletParents[FuncletEntry];
-  Parents.erase(std::remove(Parents.begin(), Parents.end(), Parent),
-                Parents.end());
-
-  // Store the cloned funclet's parent.
-  assert(std::find(FuncletParents[ClonedFunclet].begin(),
-                   FuncletParents[ClonedFunclet].end(),
-                   Parent) == std::end(FuncletParents[ClonedFunclet]));
-  FuncletParents[ClonedFunclet].push_back(Parent);
-
-  // Copy any children of the original funclet to the clone.  We'll either
-  // clone them too or make that path unreachable when we take the next step
-  // in resolveFuncletAncestryForPath().
-  for (auto *Child : FuncletChildren[FuncletEntry]) {
-    assert(std::find(FuncletChildren[ClonedFunclet].begin(),
-                     FuncletChildren[ClonedFunclet].end(),
-                     Child) == std::end(FuncletChildren[ClonedFunclet]));
-    FuncletChildren[ClonedFunclet].push_back(Child);
-    assert(std::find(FuncletParents[Child].begin(), FuncletParents[Child].end(),
-                     ClonedFunclet) == std::end(FuncletParents[Child]));
-    FuncletParents[Child].push_back(ClonedFunclet);
-  }
-
-  // Find any blocks that unwound to the original funclet entry from the
-  // clone parent block and remap them to the clone.
-  for (auto *U : FuncletEntry->users()) {
-    auto *UT = dyn_cast<TerminatorInst>(U);
-    if (!UT)
-      continue;
-    BasicBlock *UBB = UT->getParent();
-    assert(BlockColors[UBB].size() == 1);
-    BasicBlock *UFunclet = *(BlockColors[UBB].begin());
-    // Funclets shouldn't be able to loop back on themselves.
-    assert(UFunclet != FuncletEntry);
-    // If this instruction unwinds to the original funclet from the clone
-    // parent, remap the terminator so that it unwinds to the clone instead.
-    // We will perform a similar transformation for siblings after all
-    // the siblings have been cloned.
-    if (UFunclet == Parent) {
-      // We're about to break the path from this block to the uncloned funclet
-      // entry, so remove it as a predeccessor to clean up the PHIs.
-      FuncletEntry->removePredecessor(UBB);
-      TerminatorInst *Terminator = UBB->getTerminator();
-      RemapInstruction(Terminator, VMap, RF_IgnoreMissingEntries);
-    }
-  }
-
-  // This asserts a condition that is relied upon inside the loop below,
-  // namely that no predecessors of the original funclet entry block
-  // are also predecessors of the cloned funclet entry block.
-  assert(std::all_of(pred_begin(FuncletEntry), pred_end(FuncletEntry),
-                     [&ClonedFunclet](BasicBlock *Pred) {
-                       return std::find(pred_begin(ClonedFunclet),
-                                        pred_end(ClonedFunclet),
-                                        Pred) == pred_end(ClonedFunclet);
-                     }));
-
-  // Remove any invalid PHI node entries in the cloned funclet.cl
-  std::vector<PHINode *> PHIsToErase;
-  for (Instruction &I : *ClonedFunclet) {
-    auto *PN = dyn_cast<PHINode>(&I);
-    if (!PN)
-      break;
-
-    // Predecessors of the original funclet do not reach the cloned funclet,
-    // but the cloning process assumes they will.  Remove them now.
-    for (auto *Pred : predecessors(FuncletEntry))
-      PN->removeIncomingValue(Pred, false);
-  }
-  for (auto *PN : PHIsToErase)
-    PN->eraseFromParent();
-
-  // Replace the original funclet in the parent's children vector with the
-  // cloned funclet.
-  for (auto &It : FuncletChildren[Parent]) {
-    if (It == FuncletEntry) {
-      It = ClonedFunclet;
-      break;
-    }
-  }
-
-  return ClonedFunclet;
-}
-
-// Removes the unwind edge for any exceptional terminators within the specified
-// parent funclet that previously unwound to the specified child funclet.
-void WinEHPrepare::makeFuncletEdgeUnreachable(BasicBlock *Parent,
-                                              BasicBlock *Child) {
-  for (BasicBlock *BB : FuncletBlocks[Parent]) {
-    TerminatorInst *Terminator = BB->getTerminator();
-    if (!Terminator->isExceptional())
-      continue;
-
-    // Look for terninators that unwind to the child funclet.
-    BasicBlock *UnwindDest = nullptr;
-    if (auto *I = dyn_cast<InvokeInst>(Terminator))
-      UnwindDest = I->getUnwindDest();
-    else if (auto *I = dyn_cast<CatchEndPadInst>(Terminator))
-      UnwindDest = I->getUnwindDest();
-    else if (auto *I = dyn_cast<TerminatePadInst>(Terminator))
-      UnwindDest = I->getUnwindDest();
-    // cleanupendpad, catchret and cleanupret don't represent a parent-to-child
-    // funclet transition, so we don't need to consider them here.
-
-    // If the child funclet is the unwind destination, replace the terminator
-    // with an unreachable instruction.
-    if (UnwindDest == Child)
-      removeUnwindEdge(BB);
-  }
-  // The specified parent is no longer a parent of the specified child.
-  std::vector<BasicBlock *> &Children = FuncletChildren[Parent];
-  Children.erase(std::remove(Children.begin(), Children.end(), Child),
-                 Children.end());
-}
-
-// This routine is called after funclets with multiple parents are cloned for
-// a specific parent.  Here we look for children of the specified funclet that
-// unwind to other children of that funclet and update the unwind destinations
-// to ensure that each sibling is connected to the correct clone of the sibling
-// to which it unwinds.
-//
-// If the terminator is an invoke instruction, it unwinds either to a child
-// EH pad, a cleanup end pad in the current funclet, or a catch end pad in a
-// parent funclet (which ends either the current catch pad or a sibling
-// catch pad).  If it unwinds to a child EH pad, the child will have multiple
-// parents after this funclet is cloned and this case will be handled later in
-// the resolveFuncletAncestryForPath processing.  If it unwinds to a
-// cleanup end pad in the current funclet, the instruction remapping during
-// the cloning process should have already mapped the unwind destination to
-// the cloned copy of the cleanup end pad.  If it unwinds to a catch end pad
-// there are two possibilities: either the catch end pad is the unwind
-// destination for the catch pad we are currently cloning or it is the unwind
-// destination for a sibling catch pad.  If it it the unwind destination of the
-// catch pad we are cloning, we need to update the cloned invoke instruction
-// to unwind to the cloned catch end pad.  Otherwise, we will handle this
-// later (in resolveFuncletAncestryForPath).
-static void updateSiblingToSiblingUnwind(
-    BasicBlock *CurFunclet,
-    std::map<BasicBlock *, SetVector<BasicBlock *>> &BlockColors,
-    std::map<BasicBlock *, std::set<BasicBlock *>> &FuncletBlocks,
-    std::map<BasicBlock *, std::vector<BasicBlock *>> &FuncletParents,
-    std::map<BasicBlock *, std::vector<BasicBlock *>> &FuncletChildren,
-    std::map<BasicBlock *, BasicBlock *> &Funclet2Orig) {
-  // Remap any bad sibling-to-sibling transitions for funclets that
-  // we just cloned.
-  for (BasicBlock *ChildFunclet : FuncletChildren[CurFunclet]) {
-    for (auto *BB : FuncletBlocks[ChildFunclet]) {
-      TerminatorInst *Terminator = BB->getTerminator();
-      if (!Terminator->isExceptional())
-        continue;
-
-      // See if this terminator has an unwind destination.
-      // Note that catchendpads are handled when the associated catchpad
-      // is cloned.  They don't fit the pattern we're looking for here.
-      BasicBlock *UnwindDest = nullptr;
-      if (auto *I = dyn_cast<CatchPadInst>(Terminator)) {
-        UnwindDest = I->getUnwindDest();
-        // The catchendpad is not a sibling destination.  This case should
-        // have been handled in cloneFuncletForParent().
-        if (isa<CatchEndPadInst>(Terminator)) {
-          assert(BlockColors[UnwindDest].size() == 1 &&
-                 "Cloned catchpad unwinds to an pad with multiple parents.");
-          assert(FuncletParents[UnwindDest].front() == CurFunclet &&
-                 "Cloned catchpad unwinds to the wrong parent.");
-          continue;
-        }
-      } else {
-        if (auto *I = dyn_cast<CleanupReturnInst>(Terminator))
-          UnwindDest = I->getUnwindDest();
-        else if (auto *I = dyn_cast<CleanupEndPadInst>(Terminator))
-          UnwindDest = I->getUnwindDest();
-
-        // If the cleanup unwinds to caller, there is nothing to be done.
-        if (!UnwindDest)
-          continue;
-      }
-
-      // If the destination is not a cleanup pad, catch pad or terminate pad
-      // we don't need to handle it here.
-      Instruction *EHPad = UnwindDest->getFirstNonPHI();
-      if (!isa<CleanupPadInst>(EHPad) && !isa<CatchPadInst>(EHPad) &&
-          !isa<TerminatePadInst>(EHPad))
-        continue;
-
-      // If it is one of these, then it is either a sibling of the current
-      // child funclet or a clone of one of those siblings.
-      // If it is a sibling, no action is needed.
-      if (FuncletParents[UnwindDest].size() == 1 &&
-          FuncletParents[UnwindDest].front() == CurFunclet)
-        continue;
-
-      // If the unwind destination is a clone of a sibling, we need to figure
-      // out which sibling it is a clone of and use that sibling as the
-      // unwind destination.
-      BasicBlock *DestOrig = Funclet2Orig[UnwindDest];
-      BasicBlock *TargetSibling = nullptr;
-      for (auto &Mapping : Funclet2Orig) {
-        if (Mapping.second != DestOrig)
-          continue;
-        BasicBlock *MappedFunclet = Mapping.first;
-        if (FuncletParents[MappedFunclet].size() == 1 &&
-            FuncletParents[MappedFunclet].front() == CurFunclet) {
-          TargetSibling = MappedFunclet;
-        }
-      }
-      // If we didn't find the sibling we were looking for then the
-      // unwind destination is not a clone of one of child's siblings.
-      // That's unexpected.
-      assert(TargetSibling && "Funclet unwinds to unexpected destination.");
-
-      // Update the terminator instruction to unwind to the correct sibling.
-      if (auto *I = dyn_cast<CatchPadInst>(Terminator))
-        I->setUnwindDest(TargetSibling);
-      else if (auto *I = dyn_cast<CleanupReturnInst>(Terminator))
-        I->setUnwindDest(TargetSibling);
-      else if (auto *I = dyn_cast<CleanupEndPadInst>(Terminator))
-        I->setUnwindDest(TargetSibling);
-    }
-  }
-  
-  // Invoke remapping can't be done correctly until after all of their
-  // other sibling-to-sibling unwinds have been remapped.
-  for (BasicBlock *ChildFunclet : FuncletChildren[CurFunclet]) {
-    bool NeedOrigInvokeRemapping = false;
-    for (auto *BB : FuncletBlocks[ChildFunclet]) {
-      TerminatorInst *Terminator = BB->getTerminator();
-      auto *II = dyn_cast<InvokeInst>(Terminator);
-      if (!II)
-        continue;
-
-      BasicBlock *UnwindDest = II->getUnwindDest();
-      assert(UnwindDest && "Invoke unwinds to a null destination.");
-      assert(UnwindDest->isEHPad() && "Invoke does not unwind to an EH pad.");
-      auto *EHPadInst = UnwindDest->getFirstNonPHI();
-      if (isa<CleanupEndPadInst>(EHPadInst)) {
-        // An invoke that unwinds to a cleanup end pad must be in a cleanup pad.
-        assert(isa<CleanupPadInst>(ChildFunclet->getFirstNonPHI()) &&
-               "Unwinding to cleanup end pad from a non cleanup pad funclet.");
-        // The funclet cloning should have remapped the destination to the cloned
-        // cleanup end pad.
-        assert(FuncletBlocks[ChildFunclet].count(UnwindDest) &&
-               "Unwind destination for invoke was not updated during cloning.");
-      } else if (isa<CatchEndPadInst>(EHPadInst)) {
-        // If the invoke unwind destination is the unwind destination for
-        // the current child catch pad funclet, there is nothing to be done.
-        BasicBlock *OrigFunclet = Funclet2Orig[ChildFunclet];
-        auto *CurCatch = cast<CatchPadInst>(ChildFunclet->getFirstNonPHI());
-        auto *OrigCatch = cast<CatchPadInst>(OrigFunclet->getFirstNonPHI());
-        if (OrigCatch->getUnwindDest() == UnwindDest) {
-          // If the invoke unwinds to a catch end pad that is the unwind
-          // destination for the original catch pad, the cloned invoke should
-          // unwind to the cloned catch end pad.
-          II->setUnwindDest(CurCatch->getUnwindDest());
-        } else if (CurCatch->getUnwindDest() == UnwindDest) {
-          // If the invoke unwinds to a catch end pad that is the unwind
-          // destination for the clone catch pad, the original invoke should
-          // unwind to the unwind destination of the original catch pad.
-          // This happens when the catch end pad is matched to the clone
-          // parent when the catchpad instruction is cloned and the original
-          // invoke instruction unwinds to the original catch end pad (which
-          // is now the unwind destination of the cloned catch pad).
-          NeedOrigInvokeRemapping = true;
-        } else {
-          // Otherwise, the invoke unwinds to a catch end pad that is the unwind
-          // destination another catch pad in the unwind chain from either the
-          // current catch pad or one of its clones.  If it is already the
-          // catch end pad at the end unwind chain from the current catch pad,
-          // we'll need to check the invoke instructions in the original funclet
-          // later.  Otherwise, we need to remap this invoke now.
-          assert((getEndPadForCatch(OrigCatch) == UnwindDest ||
-                  getEndPadForCatch(CurCatch) == UnwindDest) &&
-                "Invoke within catch pad unwinds to an invalid catch end pad.");
-          BasicBlock *CurCatchEnd = getEndPadForCatch(CurCatch);
-          if (CurCatchEnd == UnwindDest)
-            NeedOrigInvokeRemapping = true;
-          else
-            II->setUnwindDest(CurCatchEnd);
-        }
-      }
-    }
-    if (NeedOrigInvokeRemapping) {
-      // To properly remap invoke instructions that unwind to catch end pads
-      // that are not the unwind destination of the catch pad funclet in which
-      // the invoke appears, we must also look at the uncloned invoke in the
-      // original funclet.  If we saw an invoke that was already properly
-      // unwinding to a sibling's catch end pad, we need to check the invokes
-      // in the original funclet.
-      BasicBlock *OrigFunclet = Funclet2Orig[ChildFunclet];
-      for (auto *BB : FuncletBlocks[OrigFunclet]) {
-        auto *II = dyn_cast<InvokeInst>(BB->getTerminator());
-        if (!II)
-          continue;
-
-        BasicBlock *UnwindDest = II->getUnwindDest();
-        assert(UnwindDest && "Invoke unwinds to a null destination.");
-        assert(UnwindDest->isEHPad() && "Invoke does not unwind to an EH pad.");
-        auto *CEP = dyn_cast<CatchEndPadInst>(UnwindDest->getFirstNonPHI());
-        if (!CEP)
-          continue;
-
-        // If the invoke unwind destination is the unwind destination for
-        // the original catch pad funclet, there is nothing to be done.
-        auto *OrigCatch = cast<CatchPadInst>(OrigFunclet->getFirstNonPHI());
-
-        // If the invoke unwinds to a catch end pad that is neither the unwind
-        // destination of OrigCatch or the destination another catch pad in the
-        // unwind chain from current catch pad, we need to remap the invoke.
-        BasicBlock *OrigCatchEnd = getEndPadForCatch(OrigCatch);
-        if (OrigCatchEnd != UnwindDest)
-          II->setUnwindDest(OrigCatchEnd);
-      }
-    }
-  }
-}
-
-void WinEHPrepare::resolveFuncletAncestry(
-    Function &F, SmallVectorImpl<BasicBlock *> &EntryBlocks) {
-  // Most of the time this will be unnecessary.  If the conditions arise that
-  // require this work, this flag will be set.
-  if (!FuncletCloningRequired)
-    return;
-  
-  // Funclet2Orig is used to map any cloned funclets back to the original
-  // funclet from which they were cloned.  The map is seeded with the
-  // original funclets mapping to themselves.
-  std::map<BasicBlock *, BasicBlock *> Funclet2Orig;
-  for (auto *Funclet : EntryBlocks)
-    Funclet2Orig[Funclet] = Funclet;
-
-  // Start with the entry funclet and walk the funclet parent-child tree.
-  SmallVector<BasicBlock *, 4> FuncletPath;
-  FuncletPath.push_back(&(F.getEntryBlock()));
-  resolveFuncletAncestryForPath(F, FuncletPath, Funclet2Orig);
-}
-
-// Walks the funclet control flow, cloning any funclets that have more than one
-// parent funclet and breaking any cyclic unwind chains so that the path becomes
-// unreachable at the point where a funclet would have unwound to a funclet that
-// was already in the chain.
-void WinEHPrepare::resolveFuncletAncestryForPath(
-    Function &F, SmallVectorImpl<BasicBlock *> &FuncletPath,
-    std::map<BasicBlock *, BasicBlock *> &Funclet2Orig) {
-  bool ClonedAnyChildren = false;
-  BasicBlock *CurFunclet = FuncletPath.back();
-  // Copy the children vector because we might changing it.
-  std::vector<BasicBlock *> Children(FuncletChildren[CurFunclet]);
-  for (BasicBlock *ChildFunclet : Children) {
-    // Don't allow the funclet chain to unwind back on itself.
-    // If this funclet is already in the current funclet chain, make the
-    // path to it through the current funclet unreachable.
-    bool IsCyclic = false;
-    BasicBlock *ChildIdentity = Funclet2Orig[ChildFunclet];
-    for (BasicBlock *Ancestor : FuncletPath) {
-      BasicBlock *AncestorIdentity = Funclet2Orig[Ancestor];
-      if (AncestorIdentity == ChildIdentity) {
-        IsCyclic = true;
-        break;
-      }
-    }
-    // If the unwind chain wraps back on itself, break the chain.
-    if (IsCyclic) {
-      makeFuncletEdgeUnreachable(CurFunclet, ChildFunclet);
-      continue;
-    }
-    // If this child funclet has other parents, clone the entire funclet.
-    if (FuncletParents[ChildFunclet].size() > 1) {
-      ChildFunclet = cloneFuncletForParent(F, ChildFunclet, CurFunclet);
-      Funclet2Orig[ChildFunclet] = ChildIdentity;
-      ClonedAnyChildren = true;
-    }
-    FuncletPath.push_back(ChildFunclet);
-    resolveFuncletAncestryForPath(F, FuncletPath, Funclet2Orig);
-    FuncletPath.pop_back();
-  }
-  // If we didn't clone any children, we can return now.
-  if (!ClonedAnyChildren)
-    return;
-
-  updateSiblingToSiblingUnwind(CurFunclet, BlockColors, FuncletBlocks,
-                               FuncletParents, FuncletChildren, Funclet2Orig);
-}
-
-void WinEHPrepare::colorFunclets(Function &F,
-                                 SmallVectorImpl<BasicBlock *> &EntryBlocks) {
-  ::colorFunclets(F, EntryBlocks, BlockColors, FuncletBlocks);
-
-  // The processing above actually accumulated the parent set for this
-  // funclet into the color set for its entry; use the parent set to
-  // populate the children map, and reset the color set to include just
-  // the funclet itself (no instruction can target a funclet entry except on
-  // that transitions to the child funclet).
-  for (BasicBlock *FuncletEntry : EntryBlocks) {
-    SetVector<BasicBlock *> &ColorMapItem = BlockColors[FuncletEntry];
-    // It will be rare for funclets to have multiple parents, but if any
-    // do we need to clone the funclet later to address that.  Here we
-    // set a flag indicating that this case has arisen so that we don't
-    // have to do a lot of checking later to handle the more common case.
-    if (ColorMapItem.size() > 1)
-      FuncletCloningRequired = true;
-    for (BasicBlock *Parent : ColorMapItem) {
-      assert(std::find(FuncletChildren[Parent].begin(),
-                       FuncletChildren[Parent].end(),
-                       FuncletEntry) == std::end(FuncletChildren[Parent]));
-      FuncletChildren[Parent].push_back(FuncletEntry);
-      assert(std::find(FuncletParents[FuncletEntry].begin(),
-                       FuncletParents[FuncletEntry].end(),
-                       Parent) == std::end(FuncletParents[FuncletEntry]));
-      FuncletParents[FuncletEntry].push_back(Parent);
-    }
-    ColorMapItem.clear();
-    ColorMapItem.insert(FuncletEntry);
+  // Invert the map from BB to colors to color to BBs.
+  for (BasicBlock &BB : F) {
+    ColorVector &Colors = BlockColors[&BB];
+    for (BasicBlock *Color : Colors)
+      FuncletBlocks[Color].push_back(&BB);
   }
 }
 
 void llvm::calculateCatchReturnSuccessorColors(const Function *Fn,
                                                WinEHFuncInfo &FuncInfo) {
-  SmallVector<BasicBlock *, 4> EntryBlocks;
-  // colorFunclets needs the set of EntryBlocks, get them using
-  // findFuncletEntryPoints.
-  findFuncletEntryPoints(const_cast<Function &>(*Fn), EntryBlocks);
-
-  std::map<BasicBlock *, SetVector<BasicBlock *>> BlockColors;
-  std::map<BasicBlock *, std::set<BasicBlock *>> FuncletBlocks;
-  // Figure out which basic blocks belong to which funclets.
-  colorFunclets(const_cast<Function &>(*Fn), EntryBlocks, BlockColors,
-                FuncletBlocks);
-
-  // The static colorFunclets routine assigns multiple colors to funclet entries
-  // because that information is needed to calculate funclets' parent-child
-  // relationship, but we don't need those relationship here and ultimately the
-  // entry blocks should have the color of the funclet they begin.
-  for (BasicBlock *FuncletEntry : EntryBlocks) {
-    BlockColors[FuncletEntry].clear();
-    BlockColors[FuncletEntry].insert(FuncletEntry);
-  }
-
-  // We need to find the catchret successors.  To do this, we must first find
-  // all the catchpad funclets.
-  for (auto &Funclet : FuncletBlocks) {
-    // Figure out what kind of funclet we are looking at; We only care about
-    // catchpads.
-    BasicBlock *FuncletPadBB = Funclet.first;
-    Instruction *FirstNonPHI = FuncletPadBB->getFirstNonPHI();
-    auto *CatchPad = dyn_cast<CatchPadInst>(FirstNonPHI);
-    if (!CatchPad)
-      continue;
-
-    // The users of a catchpad are always catchrets.
-    for (User *Exit : CatchPad->users()) {
-      auto *CatchReturn = dyn_cast<CatchReturnInst>(Exit);
-      if (!CatchReturn)
-        continue;
-      BasicBlock *CatchRetSuccessor = CatchReturn->getSuccessor();
-      SetVector<BasicBlock *> &SuccessorColors = BlockColors[CatchRetSuccessor];
-      assert(SuccessorColors.size() == 1 && "Expected BB to be monochrome!");
-      BasicBlock *Color = *SuccessorColors.begin();
-      // Record the catchret successor's funclet membership.
-      FuncInfo.CatchRetSuccessorColorMap[CatchReturn] = Color;
-    }
+  for (const BasicBlock &BB : *Fn) {
+    const auto *CatchRet = dyn_cast<CatchReturnInst>(BB.getTerminator());
+    if (!CatchRet)
+    // A 'catchret' returns to the outer scope's color.
+    Value *ParentPad = CatchRet->getParentPad();
+    const BasicBlock *Color;
+    if (isa<ConstantTokenNone>(ParentPad))
+      Color = &Fn->getEntryBlock();
+    else
+      Color = cast<Instruction>(ParentPad)->getParent();
+    FuncInfo.CatchRetSuccessorColorMap[CatchRet] = Color;
   }
 }
 
 void WinEHPrepare::demotePHIsOnFunclets(Function &F) {
   // Strip PHI nodes off of EH pads.
   SmallVector<PHINode *, 16> PHINodes;
   for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE;) {
     BasicBlock *BB = &*FI++;
void WinEHPrepare::demotePHIsOnFunclets(Function &F) {
 
   for (auto *PN : PHINodes) {
     // There may be lingering uses on other EH PHIs being removed
     PN->replaceAllUsesWith(UndefValue::get(PN->getType()));
     PN->eraseFromParent();
   }
 }
 
-void WinEHPrepare::cloneCommonBlocks(
-    Function &F, SmallVectorImpl<BasicBlock *> &EntryBlocks) {
+void WinEHPrepare::cloneCommonBlocks(Function &F) {
   // We need to clone all blocks which belong to multiple funclets.  Values are
   // remapped throughout the funclet to propogate both the new instructions
   // *and* the new basic blocks themselves.
-  for (BasicBlock *FuncletPadBB : EntryBlocks) {
-    std::set<BasicBlock *> &BlocksInFunclet = FuncletBlocks[FuncletPadBB];
+  for (auto &Funclets : FuncletBlocks) {
+    BasicBlock *FuncletPadBB = Funclets.first;
+    std::vector<BasicBlock *> &BlocksInFunclet = Funclets.second;
 
-    std::map<BasicBlock *, BasicBlock *> Orig2Clone;
+    std::vector<std::pair<BasicBlock *, BasicBlock *>> Orig2Clone;
     ValueToValueMapTy VMap;
-    for (auto BlockIt = BlocksInFunclet.begin(),
-              BlockEnd = BlocksInFunclet.end();
-         BlockIt != BlockEnd;) {
-      // Increment the iterator inside the loop because we might be removing
-      // blocks from the set.
-      BasicBlock *BB = *BlockIt++;
-      SetVector<BasicBlock *> &ColorsForBB = BlockColors[BB];
+    for (BasicBlock *BB : BlocksInFunclet) {
+      ColorVector &ColorsForBB = BlockColors[BB];
       // We don't need to do anything if the block is monochromatic.
       size_t NumColorsForBB = ColorsForBB.size();
       if (NumColorsForBB == 1)
         continue;
 
-      // If this block is a catchendpad, it shouldn't be cloned.
-      // We will only see a catchendpad with multiple colors in the case where
-      // some funclet has multiple parents.  In that case, the color will be
-      // resolved during the resolveFuncletAncestry processing.
-      // For now, find the catchpad that unwinds to this block and assign
-      // that catchpad's first parent to be the color for this block.
-      if (isa<CatchEndPadInst>(BB->getFirstNonPHI())) {
-        assert(
-            FuncletCloningRequired &&
-            "Found multi-colored catchendpad with no multi-parent funclets.");
-        BasicBlock *CatchParent = nullptr;
-        // There can only be one catchpad predecessor for a catchendpad.
-        for (BasicBlock *PredBB : predecessors(BB)) {
-          if (isa<CatchPadInst>(PredBB->getTerminator())) {
-            CatchParent = PredBB;
-            break;
-          }
-        }
-        // There must be one catchpad predecessor for a catchendpad.
-        assert(CatchParent && "No catchpad found for catchendpad.");
-
-        // If the catchpad has multiple parents, we'll clone the catchendpad
-        // when we clone the catchpad funclet and insert it into the correct
-        // funclet.  For now, we just select the first parent of the catchpad
-        // and give the catchendpad that color.
-        BasicBlock *CorrectColor = FuncletParents[CatchParent].front();
-        assert(FuncletBlocks[CorrectColor].count(BB));
-        assert(BlockColors[BB].count(CorrectColor));
-
-        // Remove this block from the FuncletBlocks set of any funclet that
-        // isn't the funclet whose color we just selected.
-        for (BasicBlock *ContainingFunclet : BlockColors[BB])
-          if (ContainingFunclet != CorrectColor)
-            FuncletBlocks[ContainingFunclet].erase(BB);
-        BlockColors[BB].remove_if([&](BasicBlock *ContainingFunclet) {
-          return ContainingFunclet != CorrectColor;
-        });
-        // This should leave just one color for BB.
-        assert(BlockColors[BB].size() == 1);
-        continue;
-      }
-
       DEBUG_WITH_TYPE("winehprepare-coloring",
                       dbgs() << "  Cloning block \'" << BB->getName()
                               << "\' for funclet \'" << FuncletPadBB->getName()
                               << "\'.\n");
 
       // Create a new basic block and copy instructions into it!
       BasicBlock *CBB =
           CloneBasicBlock(BB, VMap, Twine(".for.", FuncletPadBB->getName()));
       // Insert the clone immediately after the original to ensure determinism
       // and to keep the same relative ordering of any funclet's blocks.
       CBB->insertInto(&F, BB->getNextNode());
 
       // Add basic block mapping.
       VMap[BB] = CBB;
 
       // Record delta operations that we need to perform to our color mappings.
-      Orig2Clone[BB] = CBB;
+      Orig2Clone.emplace_back(BB, CBB);
     }
 
     // If nothing was cloned, we're done cloning in this funclet.
     if (Orig2Clone.empty())
       continue;
 
     // Update our color mappings to reflect that one block has lost a color and
     // another has gained a color.
     for (auto &BBMapping : Orig2Clone) {
       BasicBlock *OldBlock = BBMapping.first;
       BasicBlock *NewBlock = BBMapping.second;
 
-      BlocksInFunclet.insert(NewBlock);
-      BlockColors[NewBlock].insert(FuncletPadBB);
+      BlocksInFunclet.push_back(NewBlock);
+      ColorVector &NewColors = BlockColors[NewBlock];
+      assert(NewColors.empty() && "A new block should only have one color!");
+      NewColors.push_back(FuncletPadBB);
 
       DEBUG_WITH_TYPE("winehprepare-coloring",
                       dbgs() << "  Assigned color \'" << FuncletPadBB->getName()
                               << "\' to block \'" << NewBlock->getName()
                               << "\'.\n");
 
-      BlocksInFunclet.erase(OldBlock);
-      BlockColors[OldBlock].remove(FuncletPadBB);
+      BlocksInFunclet.erase(
+          std::remove(BlocksInFunclet.begin(), BlocksInFunclet.end(), OldBlock),
+          BlocksInFunclet.end());
+      ColorVector &OldColors = BlockColors[OldBlock];
+      OldColors.erase(
+          std::remove(OldColors.begin(), OldColors.end(), FuncletPadBB),
+          OldColors.end());
 
       DEBUG_WITH_TYPE("winehprepare-coloring",
                       dbgs() << "  Removed color \'" << FuncletPadBB->getName()
                               << "\' from block \'" << OldBlock->getName()
                               << "\'.\n");
-
-      // If we are cloning a funclet that might share a child funclet with
-      // another funclet, look to see if the cloned block is reached from a
-      // catchret instruction.  If so, save this association so we can retrieve
-      // the possibly orphaned clone when we clone the child funclet.
-      if (FuncletCloningRequired) {
-        for (auto *Pred : predecessors(OldBlock)) {
-          auto *Terminator = Pred->getTerminator();
-          if (!isa<CatchReturnInst>(Terminator))
-            continue;
-          // If this block is reached from a catchret instruction in a funclet
-          // that has multiple parents, it will have a color for each of those
-          // parents.  We just removed the color of one of the parents, but
-          // the cloned block will be unreachable until we clone the child
-          // funclet that contains the catchret instruction.  In that case we
-          // need to create a mapping that will let us find the cloned block
-          // later and associate it with the cloned child funclet.
-          bool BlockWillBeEstranged = false;
-          for (auto *Color : BlockColors[Pred]) {
-            if (FuncletParents[Color].size() > 1) {
-              BlockWillBeEstranged = true;
-              break; // Breaks out of the color loop
-            }
-          }
-          if (BlockWillBeEstranged) {
-            EstrangedBlocks[FuncletPadBB][OldBlock] = NewBlock;
-            DEBUG_WITH_TYPE("winehprepare-coloring",
-                            dbgs() << "  Saved mapping of estranged block \'"
-                                  << NewBlock->getName() << "\' for \'"
-                                  << FuncletPadBB->getName() << "\'.\n");
-            break; // Breaks out of the predecessor loop
-          }
-        }
-      }
     }
 
     // Loop over all of the instructions in this funclet, fixing up operand
     // references as we go.  This uses VMap to do all the hard work.
     for (BasicBlock *BB : BlocksInFunclet)
       // Loop over all instructions, fixing each one as we find it...
       for (Instruction &I : *BB)
         RemapInstruction(&I, VMap,
                          RF_IgnoreMissingEntries | RF_NoModuleLevelChanges);
 
+    auto UpdatePHIOnClonedBlock = [&](PHINode *PN, bool IsForOldBlock) {
+      unsigned NumPreds = PN->getNumIncomingValues();
+      for (unsigned PredIdx = 0, PredEnd = NumPreds; PredIdx != PredEnd;
+           ++PredIdx) {
+        BasicBlock *IncomingBlock = PN->getIncomingBlock(PredIdx);
+        ColorVector &IncomingColors = BlockColors[IncomingBlock];
+        bool BlockInFunclet = IncomingColors.size() == 1 &&
+                              IncomingColors.front() == FuncletPadBB;
+        if (IsForOldBlock != BlockInFunclet)
+          continue;
+        PN->removeIncomingValue(IncomingBlock, /*DeletePHIIfEmpty=*/false);
+        // Revisit the next entry.
+        --PredIdx;
+        --PredEnd;
+      }
+    };
+
+    for (auto &BBMapping : Orig2Clone) {
+      BasicBlock *OldBlock = BBMapping.first;
+      BasicBlock *NewBlock = BBMapping.second;
+      for (Instruction &OldI : *OldBlock) {
+        auto *OldPN = dyn_cast<PHINode>(&OldI);
+        if (!OldPN)
+          break;
+        UpdatePHIOnClonedBlock(OldPN, /*IsForOldBlock=*/true);
+      }
+      for (Instruction &NewI : *NewBlock) {
+        auto *NewPN = dyn_cast<PHINode>(&NewI);
+        if (!NewPN)
+          break;
+        UpdatePHIOnClonedBlock(NewPN, /*IsForOldBlock=*/false);
+      }
+    }
+
     // Check to see if SuccBB has PHI nodes. If so, we need to add entries to
     // the PHI nodes for NewBB now.
     for (auto &BBMapping : Orig2Clone) {
       BasicBlock *OldBlock = BBMapping.first;
       BasicBlock *NewBlock = BBMapping.second;
       for (BasicBlock *SuccBB : successors(NewBlock)) {
         for (Instruction &SuccI : *SuccBB) {
           auto *SuccPN = dyn_cast<PHINode>(&SuccI);
for (ValueToValueMapTy::value_type VT : VMap) {
       if (!OldI)
         continue;
       auto *NewI = cast<Instruction>(VT.second);
       // Scan all uses of this instruction to see if it is used outside of its
       // funclet, and if so, record them in UsesToRename.
       for (Use &U : OldI->uses()) {
         Instruction *UserI = cast<Instruction>(U.getUser());
         BasicBlock *UserBB = UserI->getParent();
-        SetVector<BasicBlock *> &ColorsForUserBB = BlockColors[UserBB];
+        ColorVector &ColorsForUserBB = BlockColors[UserBB];
         assert(!ColorsForUserBB.empty());
         if (ColorsForUserBB.size() > 1 ||
             *ColorsForUserBB.begin() != FuncletPadBB)
           UsesToRename.push_back(&U);
       }
 
       // If there are no uses outside the block, we're done with this
       // instruction.
for (auto &Funclets : FuncletBlocks) {
     }
   }
 }
 
 void WinEHPrepare::removeImplausibleTerminators(Function &F) {
   // Remove implausible terminators and replace them with UnreachableInst.
   for (auto &Funclet : FuncletBlocks) {
     BasicBlock *FuncletPadBB = Funclet.first;
-    std::set<BasicBlock *> &BlocksInFunclet = Funclet.second;
-    Instruction *FirstNonPHI = FuncletPadBB->getFirstNonPHI();
-    auto *CatchPad = dyn_cast<CatchPadInst>(FirstNonPHI);
-    auto *CleanupPad = dyn_cast<CleanupPadInst>(FirstNonPHI);
+    std::vector<BasicBlock *> &BlocksInFunclet = Funclet.second;
+    Instruction *FuncletPadInst = FuncletPadBB->getFirstNonPHI();
+    auto *CatchPad = dyn_cast<CatchPadInst>(FuncletPadInst);
+    auto *CleanupPad = dyn_cast<CleanupPadInst>(FuncletPadInst);
 
     for (BasicBlock *BB : BlocksInFunclet) {
       TerminatorInst *TI = BB->getTerminator();
       // CatchPadInst and CleanupPadInst can't transfer control to a ReturnInst.
       bool IsUnreachableRet = isa<ReturnInst>(TI) && (CatchPad || CleanupPad);
       // The token consumed by a CatchReturnInst must match the funclet token.
       bool IsUnreachableCatchret = false;
       if (auto *CRI = dyn_cast<CatchReturnInst>(TI))
         IsUnreachableCatchret = CRI->getCatchPad() != CatchPad;
       // The token consumed by a CleanupReturnInst must match the funclet token.
       bool IsUnreachableCleanupret = false;
       if (auto *CRI = dyn_cast<CleanupReturnInst>(TI))
         IsUnreachableCleanupret = CRI->getCleanupPad() != CleanupPad;
-      // The token consumed by a CleanupEndPadInst must match the funclet token.
-      bool IsUnreachableCleanupendpad = false;
-      if (auto *CEPI = dyn_cast<CleanupEndPadInst>(TI))
-        IsUnreachableCleanupendpad = CEPI->getCleanupPad() != CleanupPad;
       if (IsUnreachableRet || IsUnreachableCatchret ||
-          IsUnreachableCleanupret || IsUnreachableCleanupendpad) {
+          IsUnreachableCleanupret) {
         // Loop through all of our successors and make sure they know that one
         // of their predecessors is going away.
         for (BasicBlock *SuccBB : TI->successors())
           SuccBB->removePredecessor(BB);
 
-        if (IsUnreachableCleanupendpad) {
-          // We can't simply replace a cleanupendpad with unreachable, because
-          // its predecessor edges are EH edges and unreachable is not an EH
-          // pad.  Change all predecessors to the "unwind to caller" form.
-          for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
-               PI != PE;) {
-            BasicBlock *Pred = *PI++;
-            removeUnwindEdge(Pred);
-          }
-        }
-
         new UnreachableInst(BB->getContext(), TI);
         TI->eraseFromParent();
+      } else if (isa<InvokeInst>(TI)) {
+        // Invokes within a cleanuppad for the MSVC++ personality never
+        // transfer control to their unwind edge: the personality will
+        // terminate the program.
+        if (Personality == EHPersonality::MSVC_CXX && CleanupPad)
+          removeUnwindEdge(BB);
       }
-      // FIXME: Check for invokes/cleanuprets/cleanupendpads which unwind to
-      // implausible catchendpads (i.e. catchendpad not in immediate parent
-      // funclet).
     }
   }
 }
 
 void WinEHPrepare::cleanupPreparedFunclets(Function &F) {
   // Clean-up some of the mess we made by removing useles PHI nodes, trivial
   // branches, etc.
   for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE;) {
void WinEHPrepare::verifyPreparedFunclets(Function &F) {
   // Recolor the CFG to verify that all is well.
   for (BasicBlock &BB : F) {
     size_t NumColors = BlockColors[&BB].size();
     assert(NumColors == 1 && "Expected monochromatic BB!");
     if (NumColors == 0)
       report_fatal_error("Uncolored BB!");
     if (NumColors > 1)
       report_fatal_error("Multicolor BB!");
+    if (!DisableDemotion) {
       bool EHPadHasPHI = BB.isEHPad() && isa<PHINode>(BB.begin());
       assert(!EHPadHasPHI && "EH Pad still has a PHI!");
       if (EHPadHasPHI)
         report_fatal_error("EH Pad still has a PHI!");
     }
   }
+}
+
+bool WinEHPrepare::prepareExplicitEH(Function &F) {
+  // Remove unreachable blocks.  It is not valuable to assign them a color and
+  // their existence can trick us into thinking values are alive when they are
+  // not.
+  removeUnreachableBlocks(F);
 
-bool WinEHPrepare::prepareExplicitEH(
-    Function &F, SmallVectorImpl<BasicBlock *> &EntryBlocks) {
   replaceTerminatePadWithCleanup(F);
 
   // Determine which blocks are reachable from which funclet entries.
-  colorFunclets(F, EntryBlocks);
+  colorFunclets(F);
+
+  cloneCommonBlocks(F);
 
   if (!DisableDemotion)
     demotePHIsOnFunclets(F);
 
-  cloneCommonBlocks(F, EntryBlocks);
-
-  resolveFuncletAncestry(F, EntryBlocks);
-
   if (!DisableCleanups) {
     removeImplausibleTerminators(F);
 
     cleanupPreparedFunclets(F);
   }
 
   verifyPreparedFunclets(F);
 
   BlockColors.clear();
   FuncletBlocks.clear();
-  FuncletChildren.clear();
-  FuncletParents.clear();
-  EstrangedBlocks.clear();
-  FuncletCloningRequired = false;
 
   return true;
 }
 
 // TODO: Share loads when one use dominates another, or when a catchpad exit
 // dominates uses (needs dominators).
 AllocaInst *WinEHPrepare::insertPHILoads(PHINode *PN, Function &F) {
   BasicBlock *PHIBlock = PN->getParent();
   AllocaInst *SpillSlot = nullptr;
+  Instruction *EHPad = PHIBlock->getFirstNonPHI();
 
-  if (isa<CleanupPadInst>(PHIBlock->getFirstNonPHI())) {
-    // Insert a load in place of the PHI and replace all uses.
+  if (!isa<TerminatorInst>(EHPad)) {
+    // If the EHPad isn't a terminator, then we can insert a load in this block
+    // that will dominate all uses.
     SpillSlot = new AllocaInst(PN->getType(), nullptr,
                                Twine(PN->getName(), ".wineh.spillslot"),
                                &F.getEntryBlock().front());
     Value *V = new LoadInst(SpillSlot, Twine(PN->getName(), ".wineh.reload"),
                             &*PHIBlock->getFirstInsertionPt());
     PN->replaceAllUsesWith(V);
     return SpillSlot;
   }
 
+  // Otherwise, we have a PHI on a terminator EHPad, and we give up and insert
+  // loads of the slot before every use.
   DenseMap<BasicBlock *, Value *> Loads;
   for (Value::use_iterator UI = PN->use_begin(), UE = PN->use_end();
        UI != UE;) {
     Use &U = *UI++;
     auto *UsingInst = cast<Instruction>(U.getUser());
-    BasicBlock *UsingBB = UsingInst->getParent();
-    if (UsingBB->isEHPad()) {
+    if (isa<PHINode>(UsingInst) && UsingInst->getParent()->isEHPad()) {
       // Use is on an EH pad phi.  Leave it alone; we'll insert loads and
       // stores for it separately.
-      assert(isa<PHINode>(UsingInst));
       continue;
     }
     replaceUseWithLoad(PN, U, SpillSlot, Loads, F);
   }
   return SpillSlot;
 }
 
 // TODO: improve store placement.  Inserting at def is probably good, but need
void WinEHPrepare::insertPHIStores(PHINode *OriginalPHI,
   }
 }
 
 void WinEHPrepare::insertPHIStore(
     BasicBlock *PredBlock, Value *PredVal, AllocaInst *SpillSlot,
     SmallVectorImpl<std::pair<BasicBlock *, Value *>> &Worklist) {
 
   if (PredBlock->isEHPad() &&
-      !isa<CleanupPadInst>(PredBlock->getFirstNonPHI())) {
+      isa<TerminatorInst>(PredBlock->getFirstNonPHI())) {
     // Pred is unsplittable, so we need to queue it on the worklist.
     Worklist.push_back({PredBlock, PredVal});
     return;
   }
 
   // Otherwise, insert the store at the end of the basic block.
   new StoreInst(PredVal, SpillSlot, PredBlock->getTerminator());
 }
if (auto *CatchRet =
       BranchInst *Goto = cast<BranchInst>(IncomingBlock->getTerminator());
       Goto->removeFromParent();
       CatchRet->removeFromParent();
       IncomingBlock->getInstList().push_back(CatchRet);
       NewBlock->getInstList().push_back(Goto);
       Goto->setSuccessor(0, PHIBlock);
       CatchRet->setSuccessor(NewBlock);
       // Update the color mapping for the newly split edge.
-      SetVector<BasicBlock *> &ColorsForPHIBlock = BlockColors[PHIBlock];
+      ColorVector &ColorsForPHIBlock = BlockColors[PHIBlock];
       BlockColors[NewBlock] = ColorsForPHIBlock;
       for (BasicBlock *FuncletPad : ColorsForPHIBlock)
-        FuncletBlocks[FuncletPad].insert(NewBlock);
+        FuncletBlocks[FuncletPad].push_back(NewBlock);
       // Treat the new block as incoming for load insertion.
       IncomingBlock = NewBlock;
     }
     Value *&Load = Loads[IncomingBlock];
     // Insert the load into the predecessor block
     if (!Load)
       Load = new LoadInst(SpillSlot, Twine(V->getName(), ".wineh.reload"),
                           /*Volatile=*/false, IncomingBlock->getTerminator());
 
     U.set(Load);
   } else {
     // Reload right before the old use.
     auto *Load = new LoadInst(SpillSlot, Twine(V->getName(), ".wineh.reload"),
                               /*Volatile=*/false, UsingInst);
     U.set(Load);
   }
 }
 
-void WinEHFuncInfo::addIPToStateRange(const BasicBlock *PadBB,
+void WinEHFuncInfo::addIPToStateRange(const InvokeInst *II,
                                       MCSymbol *InvokeBegin,
                                       MCSymbol *InvokeEnd) {
-  assert(PadBB->isEHPad() && EHPadStateMap.count(PadBB->getFirstNonPHI()) &&
-         "should get EH pad BB with precomputed state");
-  InvokeToStateMap[InvokeBegin] =
-      std::make_pair(EHPadStateMap[PadBB->getFirstNonPHI()], InvokeEnd);
+  assert(InvokeStateMap.count(II) &&
+         "should get invoke with precomputed state");
+  LabelToStateMap[InvokeBegin] = std::make_pair(InvokeStateMap[II], InvokeEnd);
 }

llvm/trunk/lib/IR/AsmWriter.cpp

for (unsigned i = 0, e = LPI->getNumClauses(); i != e; ++i) {
       if (i != 0 || LPI->isCleanup()) Out << "\n";
       if (LPI->isCatch(i))
         Out << "          catch ";
       else
         Out << "          filter ";
 
       writeOperand(LPI->getClause(i), true);
     }
-  } else if (const auto *CPI = dyn_cast<CatchPadInst>(&I)) {
+  } else if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(&I)) {
+    Out << " within ";
+    writeOperand(CatchSwitch->getParentPad(), /*PrintType=*/false);
     Out << " [";
-    for (unsigned Op = 0, NumOps = CPI->getNumArgOperands(); Op < NumOps;
+    unsigned Op = 0;
+    for (const BasicBlock *PadBB : CatchSwitch->handlers()) {
+      if (Op > 0)
+        Out << ", ";
+      writeOperand(PadBB, /*PrintType=*/true);
+      ++Op;
+    }
+    Out << "] unwind ";
+    if (const BasicBlock *UnwindDest = CatchSwitch->getUnwindDest())
+      writeOperand(UnwindDest, /*PrintType=*/true);
+    else
+      Out << "to caller";
+  } else if (const auto *FPI = dyn_cast<FuncletPadInst>(&I)) {
+    Out << " within ";
+    writeOperand(FPI->getParentPad(), /*PrintType=*/false);
+    Out << " [";
+    for (unsigned Op = 0, NumOps = FPI->getNumArgOperands(); Op < NumOps;
          ++Op) {
       if (Op > 0)
         Out << ", ";
-      writeOperand(CPI->getArgOperand(Op), /*PrintType=*/true);
+      writeOperand(FPI->getArgOperand(Op), /*PrintType=*/true);
     }
-    Out << "]\n          to ";
-    writeOperand(CPI->getNormalDest(), /*PrintType=*/true);
-    Out << " unwind ";
-    writeOperand(CPI->getUnwindDest(), /*PrintType=*/true);
+    Out << ']';
   } else if (const auto *TPI = dyn_cast<TerminatePadInst>(&I)) {
+    Out << " within ";
+    writeOperand(TPI->getParentPad(), /*PrintType=*/false);
     Out << " [";
     for (unsigned Op = 0, NumOps = TPI->getNumArgOperands(); Op < NumOps;
          ++Op) {
       if (Op > 0)
         Out << ", ";
       writeOperand(TPI->getArgOperand(Op), /*PrintType=*/true);
     }
     Out << "] unwind ";
     if (TPI->hasUnwindDest())
       writeOperand(TPI->getUnwindDest(), /*PrintType=*/true);
     else
       Out << "to caller";
-  } else if (const auto *CPI = dyn_cast<CleanupPadInst>(&I)) {
-    Out << " [";
-    for (unsigned Op = 0, NumOps = CPI->getNumOperands(); Op < NumOps; ++Op) {
-      if (Op > 0)
-        Out << ", ";
-      writeOperand(CPI->getOperand(Op), /*PrintType=*/true);
-    }
-    Out << "]";
   } else if (isa<ReturnInst>(I) && !Operand) {
     Out << " void";
   } else if (const auto *CRI = dyn_cast<CatchReturnInst>(&I)) {
-    Out << ' ';
-    writeOperand(CRI->getCatchPad(), /*PrintType=*/false);
+    Out << " from ";
+    writeOperand(CRI->getOperand(0), /*PrintType=*/false);
 
     Out << " to ";
-    writeOperand(CRI->getSuccessor(), /*PrintType=*/true);
+    writeOperand(CRI->getOperand(1), /*PrintType=*/true);
   } else if (const auto *CRI = dyn_cast<CleanupReturnInst>(&I)) {
-    Out << ' ';
-    writeOperand(CRI->getCleanupPad(), /*PrintType=*/false);
+    Out << " from ";
+    writeOperand(CRI->getOperand(0), /*PrintType=*/false);
 
     Out << " unwind ";
     if (CRI->hasUnwindDest())
-      writeOperand(CRI->getUnwindDest(), /*PrintType=*/true);
-    else
-      Out << "to caller";
-  } else if (const auto *CEPI = dyn_cast<CatchEndPadInst>(&I)) {
-    Out << " unwind ";
-    if (CEPI->hasUnwindDest())
-      writeOperand(CEPI->getUnwindDest(), /*PrintType=*/true);
-    else
-      Out << "to caller";
-  } else if (const auto *CEPI = dyn_cast<CleanupEndPadInst>(&I)) {
-    Out << ' ';
-    writeOperand(CEPI->getCleanupPad(), /*PrintType=*/false);
-
-    Out << " unwind ";
-    if (CEPI->hasUnwindDest())
-      writeOperand(CEPI->getUnwindDest(), /*PrintType=*/true);
+      writeOperand(CRI->getOperand(1), /*PrintType=*/true);
     else
       Out << "to caller";
   } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
     // Print the calling convention being used.
     if (CI->getCallingConv() != CallingConv::C) {
       Out << " ";
       PrintCallingConv(CI->getCallingConv(), Out);
     }

llvm/trunk/lib/IR/Dominators.cpp

bool DominatorTree::dominates(const Instruction *Def,
   // Unreachable definitions don't dominate anything.
   if (!isReachableFromEntry(DefBB))
     return false;
 
   // An instruction doesn't dominate a use in itself.
   if (Def == User)
     return false;
 
-  // The value defined by an invoke/catchpad dominates an instruction only if
-  // it dominates every instruction in UseBB.
-  // A PHI is dominated only if the instruction dominates every possible use
-  // in the UseBB.
-  if (isa<InvokeInst>(Def) || isa<CatchPadInst>(Def) || isa<PHINode>(User))
+  // The value defined by an invoke dominates an instruction only if it
+  // dominates every instruction in UseBB.
+  // A PHI is dominated only if the instruction dominates every possible use in
+  // the UseBB.
+  if (isa<InvokeInst>(Def) || isa<PHINode>(User))
     return dominates(Def, UseBB);
 
   if (DefBB != UseBB)
     return dominates(DefBB, UseBB);
 
   // Loop through the basic block until we find Def or User.
   BasicBlock::const_iterator I = DefBB->begin();
   for (; &*I != Def && &*I != User; ++I)
bool DominatorTree::dominates(const Instruction *Def,
 
   // Unreachable definitions don't dominate anything.
   if (!isReachableFromEntry(DefBB))
     return false;
 
   if (DefBB == UseBB)
     return false;
 
-  // Invoke/CatchPad results are only usable in the normal destination, not in
-  // the exceptional destination.
+  // Invoke results are only usable in the normal destination, not in the
+  // exceptional destination.
   if (const auto *II = dyn_cast<InvokeInst>(Def)) {
     BasicBlock *NormalDest = II->getNormalDest();
     BasicBlockEdge E(DefBB, NormalDest);
     return dominates(E, UseBB);
   }
-  if (const auto *CPI = dyn_cast<CatchPadInst>(Def)) {
-    BasicBlock *NormalDest = CPI->getNormalDest();
-    BasicBlockEdge E(DefBB, NormalDest);
-    return dominates(E, UseBB);
-  }
 
   return dominates(DefBB, UseBB);
 }
 
 bool DominatorTree::dominates(const BasicBlockEdge &BBE,
                               const BasicBlock *UseBB) const {
   // Assert that we have a single edge. We could handle them by simply
   // returning false, but since isSingleEdge is linear on the number of
bool DominatorTree::dominates(const Instruction *Def, const Use &U) const {
   // Any unreachable use is dominated, even if Def == User.
   if (!isReachableFromEntry(UseBB))
     return true;
 
   // Unreachable definitions don't dominate anything.
   if (!isReachableFromEntry(DefBB))
     return false;
 
-  // Invoke/CatchPad instructions define their return values on the edges
-  // to their normal successors, so we have to handle them specially.
+  // Invoke instructions define their return values on the edges to their normal
+  // successors, so we have to handle them specially.
   // Among other things, this means they don't dominate anything in
   // their own block, except possibly a phi, so we don't need to
   // walk the block in any case.
   if (const InvokeInst *II = dyn_cast<InvokeInst>(Def)) {
     BasicBlock *NormalDest = II->getNormalDest();
     BasicBlockEdge E(DefBB, NormalDest);
     return dominates(E, U);
   }
-  if (const auto *CPI = dyn_cast<CatchPadInst>(Def)) {
-    BasicBlock *NormalDest = CPI->getNormalDest();
-    BasicBlockEdge E(DefBB, NormalDest);
-    return dominates(E, U);
-  }
 
   // If the def and use are in different blocks, do a simple CFG dominator
   // tree query.
   if (DefBB != UseBB)
     return dominates(DefBB, UseBB);
 
   // Ok, def and use are in the same block. If the def is an invoke, it
   // doesn't dominate anything in the block. If it's a PHI, it dominates

llvm/trunk/lib/IR/Instruction.cpp

const char *Instruction::getOpcodeName(unsigned OpCode) {
   // Terminators
   case Ret:    return "ret";
   case Br:     return "br";
   case Switch: return "switch";
   case IndirectBr: return "indirectbr";
   case Invoke: return "invoke";
   case Resume: return "resume";
   case Unreachable: return "unreachable";
-  case CleanupEndPad: return "cleanupendpad";
   case CleanupRet: return "cleanupret";
-  case CatchEndPad: return "catchendpad";
   case CatchRet: return "catchret";
   case CatchPad: return "catchpad";
+  case CatchSwitch: return "catchswitch";
   case TerminatePad: return "terminatepad";
 
   // Standard binary operators...
   case Add: return "add";
   case FAdd: return "fadd";
   case Sub: return "sub";
   case FSub: return "fsub";
   case Mul: return "mul";
bool Instruction::isAtomic() const {
   }
 }
 
 bool Instruction::mayThrow() const {
   if (const CallInst *CI = dyn_cast<CallInst>(this))
     return !CI->doesNotThrow();
   if (const auto *CRI = dyn_cast<CleanupReturnInst>(this))
     return CRI->unwindsToCaller();
-  if (const auto *CEPI = dyn_cast<CleanupEndPadInst>(this))
-    return CEPI->unwindsToCaller();
-  if (const auto *CEPI = dyn_cast<CatchEndPadInst>(this))
-    return CEPI->unwindsToCaller();
+  if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(this))
+    return CatchSwitch->unwindsToCaller();
   if (const auto *TPI = dyn_cast<TerminatePadInst>(this))
     return TPI->unwindsToCaller();
   return isa<ResumeInst>(this);
 }
 
 bool Instruction::mayReturn() const {
   if (const CallInst *CI = dyn_cast<CallInst>(this))
     return !CI->doesNotReturn();

llvm/trunk/lib/IR/Instructions.cpp

void ResumeInst::setSuccessorV(unsigned idx, BasicBlock *NewSucc) {
   llvm_unreachable("ResumeInst has no successors!");
 }
 
 BasicBlock *ResumeInst::getSuccessorV(unsigned idx) const {
   llvm_unreachable("ResumeInst has no successors!");
 }
 
 //===----------------------------------------------------------------------===//
-//                        CleanupEndPadInst Implementation
-//===----------------------------------------------------------------------===//
-
-CleanupEndPadInst::CleanupEndPadInst(const CleanupEndPadInst &CEPI)
-    : TerminatorInst(CEPI.getType(), Instruction::CleanupEndPad,
-                     OperandTraits<CleanupEndPadInst>::op_end(this) -
-                         CEPI.getNumOperands(),
-                     CEPI.getNumOperands()) {
-  setInstructionSubclassData(CEPI.getSubclassDataFromInstruction());
-  setCleanupPad(CEPI.getCleanupPad());
-  if (BasicBlock *UnwindDest = CEPI.getUnwindDest())
-    setUnwindDest(UnwindDest);
-}
-
-void CleanupEndPadInst::init(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB) {
-  setCleanupPad(CleanupPad);
-  if (UnwindBB) {
-    setInstructionSubclassData(getSubclassDataFromInstruction() | 1);
-    setUnwindDest(UnwindBB);
-  }
-}
-
-CleanupEndPadInst::CleanupEndPadInst(CleanupPadInst *CleanupPad,
-                                     BasicBlock *UnwindBB, unsigned Values,
-                                     Instruction *InsertBefore)
-    : TerminatorInst(Type::getVoidTy(CleanupPad->getContext()),
-                     Instruction::CleanupEndPad,
-                     OperandTraits<CleanupEndPadInst>::op_end(this) - Values,
-                     Values, InsertBefore) {
-  init(CleanupPad, UnwindBB);
-}
-
-CleanupEndPadInst::CleanupEndPadInst(CleanupPadInst *CleanupPad,
-                                     BasicBlock *UnwindBB, unsigned Values,
-                                     BasicBlock *InsertAtEnd)
-    : TerminatorInst(Type::getVoidTy(CleanupPad->getContext()),
-                     Instruction::CleanupEndPad,
-                     OperandTraits<CleanupEndPadInst>::op_end(this) - Values,
-                     Values, InsertAtEnd) {
-  init(CleanupPad, UnwindBB);
-}
-
-BasicBlock *CleanupEndPadInst::getSuccessorV(unsigned Idx) const {
-  assert(Idx == 0);
-  return getUnwindDest();
-}
-unsigned CleanupEndPadInst::getNumSuccessorsV() const {
-  return getNumSuccessors();
-}
-void CleanupEndPadInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
-  assert(Idx == 0);
-  setUnwindDest(B);
-}
-
-//===----------------------------------------------------------------------===//
 //                        CleanupReturnInst Implementation
 //===----------------------------------------------------------------------===//
 
 CleanupReturnInst::CleanupReturnInst(const CleanupReturnInst &CRI)
     : TerminatorInst(CRI.getType(), Instruction::CleanupRet,
                      OperandTraits<CleanupReturnInst>::op_end(this) -
                          CRI.getNumOperands(),
                      CRI.getNumOperands()) {
   setInstructionSubclassData(CRI.getSubclassDataFromInstruction());
-  Op<-1>() = CRI.Op<-1>();
+  Op<0>() = CRI.Op<0>();
   if (CRI.hasUnwindDest())
-    Op<-2>() = CRI.Op<-2>();
+    Op<1>() = CRI.Op<1>();
 }
 
-void CleanupReturnInst::init(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB) {
+void CleanupReturnInst::init(Value *CleanupPad, BasicBlock *UnwindBB) {
   if (UnwindBB)
     setInstructionSubclassData(getSubclassDataFromInstruction() | 1);
 
-  Op<-1>() = CleanupPad;
+  Op<0>() = CleanupPad;
   if (UnwindBB)
-    Op<-2>() = UnwindBB;
+    Op<1>() = UnwindBB;
 }
 
-CleanupReturnInst::CleanupReturnInst(CleanupPadInst *CleanupPad,
-                                     BasicBlock *UnwindBB, unsigned Values,
-                                     Instruction *InsertBefore)
+CleanupReturnInst::CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB,
+                                     unsigned Values, Instruction *InsertBefore)
     : TerminatorInst(Type::getVoidTy(CleanupPad->getContext()),
                      Instruction::CleanupRet,
                      OperandTraits<CleanupReturnInst>::op_end(this) - Values,
                      Values, InsertBefore) {
   init(CleanupPad, UnwindBB);
 }
 
-CleanupReturnInst::CleanupReturnInst(CleanupPadInst *CleanupPad,
-                                     BasicBlock *UnwindBB, unsigned Values,
-                                     BasicBlock *InsertAtEnd)
+CleanupReturnInst::CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB,
+                                     unsigned Values, BasicBlock *InsertAtEnd)
     : TerminatorInst(Type::getVoidTy(CleanupPad->getContext()),
                      Instruction::CleanupRet,
                      OperandTraits<CleanupReturnInst>::op_end(this) - Values,
                      Values, InsertAtEnd) {
   init(CleanupPad, UnwindBB);
 }
 
 BasicBlock *CleanupReturnInst::getSuccessorV(unsigned Idx) const {
   assert(Idx == 0);
   return getUnwindDest();
 }
 unsigned CleanupReturnInst::getNumSuccessorsV() const {
   return getNumSuccessors();
 }
 void CleanupReturnInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
   assert(Idx == 0);
   setUnwindDest(B);
 }
 
 //===----------------------------------------------------------------------===//
-//                        CatchEndPadInst Implementation
-//===----------------------------------------------------------------------===//
-
-CatchEndPadInst::CatchEndPadInst(const CatchEndPadInst &CRI)
-    : TerminatorInst(CRI.getType(), Instruction::CatchEndPad,
-                     OperandTraits<CatchEndPadInst>::op_end(this) -
-                         CRI.getNumOperands(),
-                     CRI.getNumOperands()) {
-  setInstructionSubclassData(CRI.getSubclassDataFromInstruction());
-  if (BasicBlock *UnwindDest = CRI.getUnwindDest())
-    setUnwindDest(UnwindDest);
-}
-
-void CatchEndPadInst::init(BasicBlock *UnwindBB) {
-  if (UnwindBB) {
-    setInstructionSubclassData(getSubclassDataFromInstruction() | 1);
-    setUnwindDest(UnwindBB);
-  }
-}
-
-CatchEndPadInst::CatchEndPadInst(LLVMContext &C, BasicBlock *UnwindBB,
-                                 unsigned Values, Instruction *InsertBefore)
-    : TerminatorInst(Type::getVoidTy(C), Instruction::CatchEndPad,
-                     OperandTraits<CatchEndPadInst>::op_end(this) - Values,
-                     Values, InsertBefore) {
-  init(UnwindBB);
-}
-
-CatchEndPadInst::CatchEndPadInst(LLVMContext &C, BasicBlock *UnwindBB,
-                                 unsigned Values, BasicBlock *InsertAtEnd)
-    : TerminatorInst(Type::getVoidTy(C), Instruction::CatchEndPad,
-                     OperandTraits<CatchEndPadInst>::op_end(this) - Values,
-                     Values, InsertAtEnd) {
-  init(UnwindBB);
-}
-
-BasicBlock *CatchEndPadInst::getSuccessorV(unsigned Idx) const {
-  assert(Idx == 0);
-  return getUnwindDest();
-}
-unsigned CatchEndPadInst::getNumSuccessorsV() const {
-  return getNumSuccessors();
-}
-void CatchEndPadInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
-  assert(Idx == 0);
-  setUnwindDest(B);
-}
-
-//===----------------------------------------------------------------------===//
 //                        CatchReturnInst Implementation
 //===----------------------------------------------------------------------===//
-void CatchReturnInst::init(CatchPadInst *CatchPad, BasicBlock *BB) {
+void CatchReturnInst::init(Value *CatchPad, BasicBlock *BB) {
   Op<0>() = CatchPad;
   Op<1>() = BB;
 }
 
 CatchReturnInst::CatchReturnInst(const CatchReturnInst &CRI)
     : TerminatorInst(Type::getVoidTy(CRI.getContext()), Instruction::CatchRet,
                      OperandTraits<CatchReturnInst>::op_begin(this), 2) {
   Op<0>() = CRI.Op<0>();
   Op<1>() = CRI.Op<1>();
 }
 
-CatchReturnInst::CatchReturnInst(CatchPadInst *CatchPad, BasicBlock *BB,
+CatchReturnInst::CatchReturnInst(Value *CatchPad, BasicBlock *BB,
                                  Instruction *InsertBefore)
     : TerminatorInst(Type::getVoidTy(BB->getContext()), Instruction::CatchRet,
                      OperandTraits<CatchReturnInst>::op_begin(this), 2,
                      InsertBefore) {
   init(CatchPad, BB);
 }
 
-CatchReturnInst::CatchReturnInst(CatchPadInst *CatchPad, BasicBlock *BB,
+CatchReturnInst::CatchReturnInst(Value *CatchPad, BasicBlock *BB,
                                  BasicBlock *InsertAtEnd)
     : TerminatorInst(Type::getVoidTy(BB->getContext()), Instruction::CatchRet,
                      OperandTraits<CatchReturnInst>::op_begin(this), 2,
                      InsertAtEnd) {
   init(CatchPad, BB);
 }
 
 BasicBlock *CatchReturnInst::getSuccessorV(unsigned Idx) const {
   assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!");
   return getSuccessor();
 }
 unsigned CatchReturnInst::getNumSuccessorsV() const {
   return getNumSuccessors();
 }
 void CatchReturnInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
   assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!");
   setSuccessor(B);
 }
 
 //===----------------------------------------------------------------------===//
-//                        CatchPadInst Implementation
+//                       CatchSwitchInst Implementation
 //===----------------------------------------------------------------------===//
-void CatchPadInst::init(BasicBlock *IfNormal, BasicBlock *IfException,
-                        ArrayRef<Value *> Args, const Twine &NameStr) {
-  assert(getNumOperands() == 2 + Args.size() && "NumOperands not set up?");
-  Op<-2>() = IfNormal;
-  Op<-1>() = IfException;
+
+CatchSwitchInst::CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
+                                 unsigned NumReservedValues,
+                                 const Twine &NameStr,
+                                 Instruction *InsertBefore)
+    : TerminatorInst(ParentPad->getType(), Instruction::CatchSwitch, nullptr, 0,
+                     InsertBefore) {
+  if (UnwindDest)
+    ++NumReservedValues;
+  init(ParentPad, UnwindDest, NumReservedValues + 1);
+  setName(NameStr);
+}
+
+CatchSwitchInst::CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
+                                 unsigned NumReservedValues,
+                                 const Twine &NameStr, BasicBlock *InsertAtEnd)
+    : TerminatorInst(ParentPad->getType(), Instruction::CatchSwitch, nullptr, 0,
+                     InsertAtEnd) {
+  if (UnwindDest)
+    ++NumReservedValues;
+  init(ParentPad, UnwindDest, NumReservedValues + 1);
+  setName(NameStr);
+}
+
+CatchSwitchInst::CatchSwitchInst(const CatchSwitchInst &CSI)
+    : TerminatorInst(CSI.getType(), Instruction::CatchSwitch, nullptr,
+                     CSI.getNumOperands()) {
+  init(CSI.getParentPad(), CSI.getUnwindDest(), CSI.getNumOperands());
+  setNumHungOffUseOperands(ReservedSpace);
+  Use *OL = getOperandList();
+  const Use *InOL = CSI.getOperandList();
+  for (unsigned I = 1, E = ReservedSpace; I != E; ++I)
+    OL[I] = InOL[I];
+}
+
+void CatchSwitchInst::init(Value *ParentPad, BasicBlock *UnwindDest,
+                           unsigned NumReservedValues) {
+  assert(ParentPad && NumReservedValues);
+
+  ReservedSpace = NumReservedValues;
+  setNumHungOffUseOperands(UnwindDest ? 2 : 1);
+  allocHungoffUses(ReservedSpace);
+
+  Op<0>() = ParentPad;
+  if (UnwindDest) {
+    setInstructionSubclassData(getSubclassDataFromInstruction() | 1);
+    setUnwindDest(UnwindDest);
+  }
+}
+
+/// growOperands - grow operands - This grows the operand list in response to a
+/// push_back style of operation. This grows the number of ops by 2 times.
+void CatchSwitchInst::growOperands(unsigned Size) {
+  unsigned NumOperands = getNumOperands();
+  assert(NumOperands >= 1);
+  if (ReservedSpace >= NumOperands + Size)
+    return;
+  ReservedSpace = (NumOperands + Size / 2) * 2;
+  growHungoffUses(ReservedSpace);
+}
+
+void CatchSwitchInst::addHandler(BasicBlock *Handler) {
+  unsigned OpNo = getNumOperands();
+  growOperands(1);
+  assert(OpNo < ReservedSpace && "Growing didn't work!");
+  setNumHungOffUseOperands(getNumOperands() + 1);
+  getOperandList()[OpNo] = Handler;
+}
+
+BasicBlock *CatchSwitchInst::getSuccessorV(unsigned idx) const {
+  return getSuccessor(idx);
+}
+unsigned CatchSwitchInst::getNumSuccessorsV() const {
+  return getNumSuccessors();
+}
+void CatchSwitchInst::setSuccessorV(unsigned idx, BasicBlock *B) {
+  setSuccessor(idx, B);
+}
+
+//===----------------------------------------------------------------------===//
+//                        FuncletPadInst Implementation
+//===----------------------------------------------------------------------===//
+void FuncletPadInst::init(Value *ParentPad, ArrayRef<Value *> Args,
+                          const Twine &NameStr) {
+  assert(getNumOperands() == 1 + Args.size() && "NumOperands not set up?");
   std::copy(Args.begin(), Args.end(), op_begin());
+  setParentPad(ParentPad);
   setName(NameStr);
 }
 
-CatchPadInst::CatchPadInst(const CatchPadInst &CPI)
-    : TerminatorInst(CPI.getType(), Instruction::CatchPad,
-                     OperandTraits<CatchPadInst>::op_end(this) -
-                         CPI.getNumOperands(),
-                     CPI.getNumOperands()) {
-  std::copy(CPI.op_begin(), CPI.op_end(), op_begin());
+FuncletPadInst::FuncletPadInst(const FuncletPadInst &FPI)
+    : Instruction(FPI.getType(), FPI.getOpcode(),
+                  OperandTraits<FuncletPadInst>::op_end(this) -
+                      FPI.getNumOperands(),
+                  FPI.getNumOperands()) {
+  std::copy(FPI.op_begin(), FPI.op_end(), op_begin());
+  setParentPad(FPI.getParentPad());
 }
 
-CatchPadInst::CatchPadInst(BasicBlock *IfNormal, BasicBlock *IfException,
+FuncletPadInst::FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
                                ArrayRef<Value *> Args, unsigned Values,
                                const Twine &NameStr, Instruction *InsertBefore)
-    : TerminatorInst(Type::getTokenTy(IfNormal->getContext()),
-                     Instruction::CatchPad,
-                     OperandTraits<CatchPadInst>::op_end(this) - Values, Values,
-                     InsertBefore) {
-  init(IfNormal, IfException, Args, NameStr);
+    : Instruction(ParentPad->getType(), Op,
+                  OperandTraits<FuncletPadInst>::op_end(this) - Values, Values,
+  init(ParentPad, Args, NameStr);
 }
 
-CatchPadInst::CatchPadInst(BasicBlock *IfNormal, BasicBlock *IfException,
+FuncletPadInst::FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
                                ArrayRef<Value *> Args, unsigned Values,
                                const Twine &NameStr, BasicBlock *InsertAtEnd)
-    : TerminatorInst(Type::getTokenTy(IfNormal->getContext()),
-                     Instruction::CatchPad,
-                     OperandTraits<CatchPadInst>::op_end(this) - Values, Values,
-                     InsertAtEnd) {
-  init(IfNormal, IfException, Args, NameStr);
-}
-
-BasicBlock *CatchPadInst::getSuccessorV(unsigned Idx) const {
-  return getSuccessor(Idx);
-}
-unsigned CatchPadInst::getNumSuccessorsV() const {
-  return getNumSuccessors();
-}
-void CatchPadInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
-  return setSuccessor(Idx, B);
+    : Instruction(ParentPad->getType(), Op,
+                  OperandTraits<FuncletPadInst>::op_end(this) - Values, Values,
+  init(ParentPad, Args, NameStr);
 }
 
 //===----------------------------------------------------------------------===//
 //                        TerminatePadInst Implementation
 //===----------------------------------------------------------------------===//
-void TerminatePadInst::init(BasicBlock *BB, ArrayRef<Value *> Args) {
-  if (BB)
+void TerminatePadInst::init(Value *ParentPad, BasicBlock *BB,
+                            ArrayRef<Value *> Args) {
+  if (BB) {
     setInstructionSubclassData(getSubclassDataFromInstruction() | 1);
-  if (BB)
-    Op<-1>() = BB;
-  std::copy(Args.begin(), Args.end(), op_begin());
+    setUnwindDest(BB);
+  }
+  std::copy(Args.begin(), Args.end(), arg_begin());
+  setParentPad(ParentPad);
 }
 
 TerminatePadInst::TerminatePadInst(const TerminatePadInst &TPI)
     : TerminatorInst(TPI.getType(), Instruction::TerminatePad,
                      OperandTraits<TerminatePadInst>::op_end(this) -
                          TPI.getNumOperands(),
                      TPI.getNumOperands()) {
   setInstructionSubclassData(TPI.getSubclassDataFromInstruction());
   std::copy(TPI.op_begin(), TPI.op_end(), op_begin());
 }
 
-TerminatePadInst::TerminatePadInst(LLVMContext &C, BasicBlock *BB,
+TerminatePadInst::TerminatePadInst(Value *ParentPad, BasicBlock *BB,
                                    ArrayRef<Value *> Args, unsigned Values,
                                    Instruction *InsertBefore)
-    : TerminatorInst(Type::getVoidTy(C), Instruction::TerminatePad,
+    : TerminatorInst(Type::getVoidTy(ParentPad->getContext()),
+                     Instruction::TerminatePad,
                      OperandTraits<TerminatePadInst>::op_end(this) - Values,
                      Values, InsertBefore) {
-  init(BB, Args);
+  init(ParentPad, BB, Args);
 }
 
-TerminatePadInst::TerminatePadInst(LLVMContext &C, BasicBlock *BB,
+TerminatePadInst::TerminatePadInst(Value *ParentPad, BasicBlock *BB,
                                    ArrayRef<Value *> Args, unsigned Values,
                                    BasicBlock *InsertAtEnd)
-    : TerminatorInst(Type::getVoidTy(C), Instruction::TerminatePad,
+    : TerminatorInst(Type::getVoidTy(ParentPad->getContext()),
+                     Instruction::TerminatePad,
                      OperandTraits<TerminatePadInst>::op_end(this) - Values,
                      Values, InsertAtEnd) {
-  init(BB, Args);
+  init(ParentPad, BB, Args);
 }
 
 BasicBlock *TerminatePadInst::getSuccessorV(unsigned Idx) const {
   assert(Idx == 0);
   return getUnwindDest();
 }
 unsigned TerminatePadInst::getNumSuccessorsV() const {
   return getNumSuccessors();
 }
 void TerminatePadInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
   assert(Idx == 0);
   return setUnwindDest(B);
 }
 
 //===----------------------------------------------------------------------===//
-//                        CleanupPadInst Implementation
-//===----------------------------------------------------------------------===//
-void CleanupPadInst::init(ArrayRef<Value *> Args, const Twine &NameStr) {
-  assert(getNumOperands() == Args.size() && "NumOperands not set up?");
-  std::copy(Args.begin(), Args.end(), op_begin());
-  setName(NameStr);
-}
-
-CleanupPadInst::CleanupPadInst(const CleanupPadInst &CPI)
-    : Instruction(CPI.getType(), Instruction::CleanupPad,
-                  OperandTraits<CleanupPadInst>::op_end(this) -
-                      CPI.getNumOperands(),
-                  CPI.getNumOperands()) {
-  std::copy(CPI.op_begin(), CPI.op_end(), op_begin());
-}
-
-CleanupPadInst::CleanupPadInst(LLVMContext &C, ArrayRef<Value *> Args,
-                               const Twine &NameStr, Instruction *InsertBefore)
-    : Instruction(Type::getTokenTy(C), Instruction::CleanupPad,
-                  OperandTraits<CleanupPadInst>::op_end(this) - Args.size(),
-                  Args.size(), InsertBefore) {
-  init(Args, NameStr);
-}
-
-CleanupPadInst::CleanupPadInst(LLVMContext &C, ArrayRef<Value *> Args,
-                               const Twine &NameStr, BasicBlock *InsertAtEnd)
-    : Instruction(Type::getTokenTy(C), Instruction::CleanupPad,
-                  OperandTraits<CleanupPadInst>::op_end(this) - Args.size(),
-                  Args.size(), InsertAtEnd) {
-  init(Args, NameStr);
-}
-
-//===----------------------------------------------------------------------===//
 //                      UnreachableInst Implementation
 //===----------------------------------------------------------------------===//
 
 UnreachableInst::UnreachableInst(LLVMContext &Context, 
                                  Instruction *InsertBefore)
   : TerminatorInst(Type::getVoidTy(Context), Instruction::Unreachable,
                    nullptr, 0, InsertBefore) {
 }
if (hasOperandBundles()) {
     unsigned DescriptorBytes = getNumOperandBundles() * sizeof(BundleOpInfo);
     return new(getNumOperands(), DescriptorBytes) InvokeInst(*this);
   }
   return new(getNumOperands()) InvokeInst(*this);
 }
 
 ResumeInst *ResumeInst::cloneImpl() const { return new (1) ResumeInst(*this); }
 
-CleanupEndPadInst *CleanupEndPadInst::cloneImpl() const {
-  return new (getNumOperands()) CleanupEndPadInst(*this);
-}
-
 CleanupReturnInst *CleanupReturnInst::cloneImpl() const {
   return new (getNumOperands()) CleanupReturnInst(*this);
 }
 
-CatchEndPadInst *CatchEndPadInst::cloneImpl() const {
-  return new (getNumOperands()) CatchEndPadInst(*this);
-}
-
 CatchReturnInst *CatchReturnInst::cloneImpl() const {
   return new (getNumOperands()) CatchReturnInst(*this);
 }
 
-CatchPadInst *CatchPadInst::cloneImpl() const {
-  return new (getNumOperands()) CatchPadInst(*this);
+CatchSwitchInst *CatchSwitchInst::cloneImpl() const {
+  return new CatchSwitchInst(*this);
 }
 
-TerminatePadInst *TerminatePadInst::cloneImpl() const {
-  return new (getNumOperands()) TerminatePadInst(*this);
+FuncletPadInst *FuncletPadInst::cloneImpl() const {
+  return new (getNumOperands()) FuncletPadInst(*this);
 }
 
-CleanupPadInst *CleanupPadInst::cloneImpl() const {
-  return new (getNumOperands()) CleanupPadInst(*this);
+TerminatePadInst *TerminatePadInst::cloneImpl() const {
+  return new (getNumOperands()) TerminatePadInst(*this);
 }
 
 UnreachableInst *UnreachableInst::cloneImpl() const {
   LLVMContext &Context = getContext();
   return new UnreachableInst(Context);
 }

llvm/trunk/lib/IR/Verifier.cpp

#include "llvm/IR/Metadata.def"
   void visitAtomicRMWInst(AtomicRMWInst &RMWI);
   void visitFenceInst(FenceInst &FI);
   void visitAllocaInst(AllocaInst &AI);
   void visitExtractValueInst(ExtractValueInst &EVI);
   void visitInsertValueInst(InsertValueInst &IVI);
   void visitEHPadPredecessors(Instruction &I);
   void visitLandingPadInst(LandingPadInst &LPI);
   void visitCatchPadInst(CatchPadInst &CPI);
-  void visitCatchEndPadInst(CatchEndPadInst &CEPI);
+  void visitCatchReturnInst(CatchReturnInst &CatchReturn);
   void visitCleanupPadInst(CleanupPadInst &CPI);
-  void visitCleanupEndPadInst(CleanupEndPadInst &CEPI);
+  void visitCatchSwitchInst(CatchSwitchInst &CatchSwitch);
   void visitCleanupReturnInst(CleanupReturnInst &CRI);
   void visitTerminatePadInst(TerminatePadInst &TPI);
 
   void VerifyCallSite(CallSite CS);
   void verifyMustTailCall(CallInst &CI);
   bool PerformTypeCheck(Intrinsic::ID ID, Function *F, Type *Ty, int VT,
                         unsigned ArgNo, std::string &Suffix);
   bool VerifyIntrinsicType(Type *Ty, ArrayRef<Intrinsic::IITDescriptor> &Infos,
for (BasicBlock *PredBB : predecessors(BB)) {
       const auto *II = dyn_cast<InvokeInst>(PredBB->getTerminator());
       Assert(II && II->getUnwindDest() == BB && II->getNormalDest() != BB,
              "Block containing LandingPadInst must be jumped to "
              "only by the unwind edge of an invoke.",
              LPI);
     }
     return;
   }
+  if (auto *CPI = dyn_cast<CatchPadInst>(&I)) {
+    if (!pred_empty(BB))
+      Assert(BB->getUniquePredecessor() == CPI->getCatchSwitch()->getParent(),
+             "Block containg CatchPadInst must be jumped to "
+             "only by its catchswitch.",
+             CPI);
+    return;
+  }
 
   for (BasicBlock *PredBB : predecessors(BB)) {
     TerminatorInst *TI = PredBB->getTerminator();
-    if (auto *II = dyn_cast<InvokeInst>(TI))
+    if (auto *II = dyn_cast<InvokeInst>(TI)) {
       Assert(II->getUnwindDest() == BB && II->getNormalDest() != BB,
              "EH pad must be jumped to via an unwind edge", &I, II);
-    else if (auto *CPI = dyn_cast<CatchPadInst>(TI))
-      Assert(CPI->getUnwindDest() == BB && CPI->getNormalDest() != BB,
-             "EH pad must be jumped to via an unwind edge", &I, CPI);
-    else if (isa<CatchEndPadInst>(TI))
-      ;
-    else if (isa<CleanupReturnInst>(TI))
-      ;
-    else if (isa<CleanupEndPadInst>(TI))
-      ;
-    else if (isa<TerminatePadInst>(TI))
-      ;
-    else
+    } else if (!isa<CleanupReturnInst>(TI) && !isa<TerminatePadInst>(TI) &&
+               !isa<CatchSwitchInst>(TI)) {
       Assert(false, "EH pad must be jumped to via an unwind edge", &I, TI);
     }
   }
+}
 
 void Verifier::visitLandingPadInst(LandingPadInst &LPI) {
   // The landingpad instruction is ill-formed if it doesn't have any clauses and
   // isn't a cleanup.
   Assert(LPI.getNumClauses() > 0 || LPI.isCleanup(),
          "LandingPadInst needs at least one clause or to be a cleanup.", &LPI);
 
   visitEHPadPredecessors(LPI);
void Verifier::visitLandingPadInst(LandingPadInst &LPI) {
 
   visitInstruction(LPI);
 }
 
 void Verifier::visitCatchPadInst(CatchPadInst &CPI) {
   visitEHPadPredecessors(CPI);
 
   BasicBlock *BB = CPI.getParent();
+
   Function *F = BB->getParent();
   Assert(F->hasPersonalityFn(),
          "CatchPadInst needs to be in a function with a personality.", &CPI);
 
+  Assert(isa<CatchSwitchInst>(CPI.getParentPad()),
+         "CatchPadInst needs to be directly nested in a CatchSwitchInst.",
+         CPI.getParentPad());
+
   // The catchpad instruction must be the first non-PHI instruction in the
   // block.
   Assert(BB->getFirstNonPHI() == &CPI,
-         "CatchPadInst not the first non-PHI instruction in the block.",
-         &CPI);
+         "CatchPadInst not the first non-PHI instruction in the block.", &CPI);
 
-  if (!BB->getSinglePredecessor())
-    for (BasicBlock *PredBB : predecessors(BB)) {
-      Assert(!isa<CatchPadInst>(PredBB->getTerminator()),
-             "CatchPadInst with CatchPadInst predecessor cannot have any other "
-             "predecessors.",
-             &CPI);
-    }
+  visitInstruction(CPI);
 
-  BasicBlock *UnwindDest = CPI.getUnwindDest();
-  Instruction *I = UnwindDest->getFirstNonPHI();
-  Assert(
-      isa<CatchPadInst>(I) || isa<CatchEndPadInst>(I),
-      "CatchPadInst must unwind to a CatchPadInst or a CatchEndPadInst.",
-      &CPI);
+void Verifier::visitCatchReturnInst(CatchReturnInst &CatchReturn) {
+  Assert(isa<CatchPadInst>(CatchReturn.getOperand(0)),
+         "CatchReturnInst needs to be provided a CatchPad", &CatchReturn,
+         CatchReturn.getOperand(0));
 
-  visitTerminatorInst(CPI);
-}
-
-void Verifier::visitCatchEndPadInst(CatchEndPadInst &CEPI) {
-  visitEHPadPredecessors(CEPI);
-
-  BasicBlock *BB = CEPI.getParent();
-  Function *F = BB->getParent();
-  Assert(F->hasPersonalityFn(),
-         "CatchEndPadInst needs to be in a function with a personality.",
-         &CEPI);
-
-  // The catchendpad instruction must be the first non-PHI instruction in the
-  // block.
-  Assert(BB->getFirstNonPHI() == &CEPI,
-         "CatchEndPadInst not the first non-PHI instruction in the block.",
-         &CEPI);
-
-  unsigned CatchPadsSeen = 0;
-  for (BasicBlock *PredBB : predecessors(BB))
-    if (isa<CatchPadInst>(PredBB->getTerminator()))
-      ++CatchPadsSeen;
-
-  Assert(CatchPadsSeen <= 1, "CatchEndPadInst must have no more than one "
-                               "CatchPadInst predecessor.",
-         &CEPI);
-
-  if (BasicBlock *UnwindDest = CEPI.getUnwindDest()) {
-    Instruction *I = UnwindDest->getFirstNonPHI();
-    Assert(
-        I->isEHPad() && !isa<LandingPadInst>(I),
-        "CatchEndPad must unwind to an EH block which is not a landingpad.",
-        &CEPI);
-  }
-
-  visitTerminatorInst(CEPI);
+  visitTerminatorInst(CatchReturn);
 }
 
 void Verifier::visitCleanupPadInst(CleanupPadInst &CPI) {
   visitEHPadPredecessors(CPI);
 
   BasicBlock *BB = CPI.getParent();
 
   Function *F = BB->getParent();
   Assert(F->hasPersonalityFn(),
          "CleanupPadInst needs to be in a function with a personality.", &CPI);
 
   // The cleanuppad instruction must be the first non-PHI instruction in the
   // block.
   Assert(BB->getFirstNonPHI() == &CPI,
          "CleanupPadInst not the first non-PHI instruction in the block.",
          &CPI);
 
+  auto *ParentPad = CPI.getParentPad();
+  Assert(isa<CatchSwitchInst>(ParentPad) || isa<ConstantTokenNone>(ParentPad) ||
+             isa<CleanupPadInst>(ParentPad) || isa<CatchPadInst>(ParentPad),
+         "CleanupPadInst has an invalid parent.", &CPI);
+
   User *FirstUser = nullptr;
   BasicBlock *FirstUnwindDest = nullptr;
   for (User *U : CPI.users()) {
     BasicBlock *UnwindDest;
     if (CleanupReturnInst *CRI = dyn_cast<CleanupReturnInst>(U)) {
       UnwindDest = CRI->getUnwindDest();
+    } else if (isa<CleanupPadInst>(U) || isa<CatchSwitchInst>(U) ||
+               isa<TerminatePadInst>(U)) {
+      continue;
     } else {
-      UnwindDest = cast<CleanupEndPadInst>(U)->getUnwindDest();
+      Assert(false, "bogus cleanuppad use", &CPI);
     }
 
     if (!FirstUser) {
       FirstUser = U;
       FirstUnwindDest = UnwindDest;
     } else {
-      Assert(UnwindDest == FirstUnwindDest,
-             "Cleanuprets/cleanupendpads from the same cleanuppad must "
-             "have the same unwind destination",
-             FirstUser, U);
+      Assert(
+          UnwindDest == FirstUnwindDest,
+          "cleanupret instructions from the same cleanuppad must have the same "
+          "unwind destination",
     }
   }
 
   visitInstruction(CPI);
 }
 
-void Verifier::visitCleanupEndPadInst(CleanupEndPadInst &CEPI) {
-  visitEHPadPredecessors(CEPI);
+void Verifier::visitCatchSwitchInst(CatchSwitchInst &CatchSwitch) {
+  visitEHPadPredecessors(CatchSwitch);
+
+  BasicBlock *BB = CatchSwitch.getParent();
 
-  BasicBlock *BB = CEPI.getParent();
   Function *F = BB->getParent();
   Assert(F->hasPersonalityFn(),
-         "CleanupEndPadInst needs to be in a function with a personality.",
-         &CEPI);
+         "CatchSwitchInst needs to be in a function with a personality.",
+         &CatchSwitch);
 
-  // The cleanupendpad instruction must be the first non-PHI instruction in the
+  // The catchswitch instruction must be the first non-PHI instruction in the
   // block.
-  Assert(BB->getFirstNonPHI() == &CEPI,
-         "CleanupEndPadInst not the first non-PHI instruction in the block.",
-         &CEPI);
+  Assert(BB->getFirstNonPHI() == &CatchSwitch,
+         "CatchSwitchInst not the first non-PHI instruction in the block.",
+         &CatchSwitch);
 
-  if (BasicBlock *UnwindDest = CEPI.getUnwindDest()) {
+  if (BasicBlock *UnwindDest = CatchSwitch.getUnwindDest()) {
     Instruction *I = UnwindDest->getFirstNonPHI();
-    Assert(
-        I->isEHPad() && !isa<LandingPadInst>(I),
-        "CleanupEndPad must unwind to an EH block which is not a landingpad.",
-        &CEPI);
+    Assert(I->isEHPad() && !isa<LandingPadInst>(I),
+           "CatchSwitchInst must unwind to an EH block which is not a "
+           "landingpad.",
+           &CatchSwitch);
   }
 
-  visitTerminatorInst(CEPI);
+  auto *ParentPad = CatchSwitch.getParentPad();
+  Assert(isa<CatchSwitchInst>(ParentPad) || isa<ConstantTokenNone>(ParentPad) ||
+             isa<CleanupPadInst>(ParentPad) || isa<CatchPadInst>(ParentPad),
+         "CatchSwitchInst has an invalid parent.", ParentPad);
+
+  visitTerminatorInst(CatchSwitch);
 }
 
 void Verifier::visitCleanupReturnInst(CleanupReturnInst &CRI) {
+  Assert(isa<CleanupPadInst>(CRI.getOperand(0)),
+         "CleanupReturnInst needs to be provided a CleanupPad", &CRI,
+         CRI.getOperand(0));
+
   if (BasicBlock *UnwindDest = CRI.getUnwindDest()) {
     Instruction *I = UnwindDest->getFirstNonPHI();
     Assert(I->isEHPad() && !isa<LandingPadInst>(I),
            "CleanupReturnInst must unwind to an EH block which is not a "
            "landingpad.",
            &CRI);
   }
 
void Verifier::visitTerminatePadInst(TerminatePadInst &TPI) {
   if (BasicBlock *UnwindDest = TPI.getUnwindDest()) {
     Instruction *I = UnwindDest->getFirstNonPHI();
     Assert(I->isEHPad() && !isa<LandingPadInst>(I),
            "TerminatePadInst must unwind to an EH block which is not a "
            "landingpad.",
            &TPI);
   }
 
+  auto *ParentPad = TPI.getParentPad();
+  Assert(isa<CatchSwitchInst>(ParentPad) || isa<ConstantTokenNone>(ParentPad) ||
+             isa<CleanupPadInst>(ParentPad) || isa<CatchPadInst>(ParentPad),
+         "TerminatePadInst has an invalid parent.", ParentPad);
+
   visitTerminatorInst(TPI);
 }
 
 void Verifier::verifyDominatesUse(Instruction &I, unsigned i) {
   Instruction *Op = cast<Instruction>(I.getOperand(i));
   // If the we have an invalid invoke, don't try to compute the dominance.
   // We already reject it in the invoke specific checks and the dominance
   // computation doesn't handle multiple edges.

llvm/trunk/lib/Target/X86/X86WinEHState.cpp

 // All functions using an MSVC EH personality use an explicitly updated state
 // number stored in an exception registration stack object. The registration
 // object is linked into a thread-local chain of registrations stored at fs:00.
 // This pass adds the registration object and EH state updates.
 //
 //===----------------------------------------------------------------------===//
 
 #include "X86.h"
+#include "llvm/Analysis/CFG.h"
 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/WinEHFuncInfo.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instructions.h"
void WinEHStatePass::addStateStores(Function &F, WinEHFuncInfo &FuncInfo) {
 
   // Calculate state numbers.
   if (isAsynchronousEHPersonality(Personality))
     calculateSEHStateNumbers(&F, FuncInfo);
   else
     calculateWinCXXEHStateNumbers(&F, FuncInfo);
 
   // Iterate all the instructions and emit state number stores.
+  DenseMap<BasicBlock *, ColorVector> BlockColors = colorEHFunclets(F);
   for (BasicBlock &BB : F) {
+    // Figure out what state we should assign calls in this block.
+    int BaseState = -1;
+    auto &BBColors = BlockColors[&BB];
+
+    assert(BBColors.size() == 1 &&
+           "multi-color BB not removed by preparation");
+    BasicBlock *FuncletEntryBB = BBColors.front();
+    if (auto *FuncletPad =
+            dyn_cast<FuncletPadInst>(FuncletEntryBB->getFirstNonPHI())) {
+      auto BaseStateI = FuncInfo.FuncletBaseStateMap.find(FuncletPad);
+      if (BaseStateI != FuncInfo.FuncletBaseStateMap.end())
+        BaseState = BaseStateI->second;
+    }
+
     for (Instruction &I : BB) {
       if (auto *CI = dyn_cast<CallInst>(&I)) {
         // Possibly throwing call instructions have no actions to take after
         // an unwind. Ensure they are in the -1 state.
         if (CI->doesNotThrow())
           continue;
-        insertStateNumberStore(RegNode, CI, -1);
+        insertStateNumberStore(RegNode, CI, BaseState);
       } else if (auto *II = dyn_cast<InvokeInst>(&I)) {
         // Look up the state number of the landingpad this unwinds to.
-        Instruction *PadInst = II->getUnwindDest()->getFirstNonPHI();
-        // FIXME: Why does this assertion fail?
-        //assert(FuncInfo.EHPadStateMap.count(PadInst) && "EH Pad has no state!");
-        int State = FuncInfo.EHPadStateMap[PadInst];
+        assert(FuncInfo.InvokeStateMap.count(II) && "invoke has no state!");
+        int State = FuncInfo.InvokeStateMap[II];
         insertStateNumberStore(RegNode, II, State);
       }
     }
   }
 }
 
 void WinEHStatePass::insertStateNumberStore(Value *ParentRegNode,
                                             Instruction *IP, int State) {
   IRBuilder<> Builder(IP);
   Value *StateField =
       Builder.CreateStructGEP(RegNodeTy, ParentRegNode, StateFieldIndex);
   Builder.CreateStore(Builder.getInt32(State), StateField);
 }

llvm/trunk/lib/Transforms/Instrumentation/MemorySanitizer.cpp

 
   void visitLandingPadInst(LandingPadInst &I) {
     // Do nothing.
     // See http://code.google.com/p/memory-sanitizer/issues/detail?id=1
     setShadow(&I, getCleanShadow(&I));
     setOrigin(&I, getCleanOrigin());
   }
 
-  void visitCleanupPadInst(CleanupPadInst &I) {
+  void visitCatchSwitchInst(CatchSwitchInst &I) {
     setShadow(&I, getCleanShadow(&I));
     setOrigin(&I, getCleanOrigin());
   }
 
-  void visitCatchPad(CatchPadInst &I) {
+  void visitFuncletPadInst(FuncletPadInst &I) {
     setShadow(&I, getCleanShadow(&I));
     setOrigin(&I, getCleanOrigin());
   }
 
   void visitTerminatePad(TerminatePadInst &I) {
     DEBUG(dbgs() << "TerminatePad: " << I << "\n");
     // Nothing to do here.
   }
 
-  void visitCatchEndPadInst(CatchEndPadInst &I) {
-    DEBUG(dbgs() << "CatchEndPad: " << I << "\n");
-    // Nothing to do here.
-  }
-
-  void visitCleanupEndPadInst(CleanupEndPadInst &I) {
-    DEBUG(dbgs() << "CleanupEndPad: " << I << "\n");
-    // Nothing to do here.
-  }
-
   void visitGetElementPtrInst(GetElementPtrInst &I) {
     handleShadowOr(I);
   }
 
   void visitExtractValueInst(ExtractValueInst &I) {
     IRBuilder<> IRB(&I);
     Value *Agg = I.getAggregateOperand();
     DEBUG(dbgs() << "ExtractValue:  " << I << "\n");

llvm/trunk/lib/Transforms/Scalar/Reassociate.cpp

for (User *U : V->users()) {
     // Verify that the negate is in this function, V might be a constant expr.
     if (TheNeg->getParent()->getParent() != BI->getParent()->getParent())
       continue;
 
     BasicBlock::iterator InsertPt;
     if (Instruction *InstInput = dyn_cast<Instruction>(V)) {
       if (InvokeInst *II = dyn_cast<InvokeInst>(InstInput)) {
         InsertPt = II->getNormalDest()->begin();
-      } else if (auto *CPI = dyn_cast<CatchPadInst>(InstInput)) {
-        InsertPt = CPI->getNormalDest()->begin();
       } else {
         InsertPt = ++InstInput->getIterator();
       }
       while (isa<PHINode>(InsertPt)) ++InsertPt;
     } else {
       InsertPt = TheNeg->getParent()->getParent()->getEntryBlock().begin();
     }
     TheNeg->moveBefore(&*InsertPt);

llvm/trunk/lib/Transforms/Scalar/SCCP.cpp

private:
   void visitBinaryOperator(Instruction &I);
   void visitCmpInst(CmpInst &I);
   void visitExtractElementInst(ExtractElementInst &I);
   void visitInsertElementInst(InsertElementInst &I);
   void visitShuffleVectorInst(ShuffleVectorInst &I);
   void visitExtractValueInst(ExtractValueInst &EVI);
   void visitInsertValueInst(InsertValueInst &IVI);
   void visitLandingPadInst(LandingPadInst &I) { markAnythingOverdefined(&I); }
-  void visitCleanupPadInst(CleanupPadInst &CPI) { markAnythingOverdefined(&CPI); }
-  void visitCatchPadInst(CatchPadInst &CPI) {
+  void visitFuncletPadInst(FuncletPadInst &FPI) {
+    markAnythingOverdefined(&FPI);
+  }
+  void visitCatchSwitchInst(CatchSwitchInst &CPI) {
     markAnythingOverdefined(&CPI);
     visitTerminatorInst(CPI);
   }
 
   // Instructions that cannot be folded away.
   void visitStoreInst     (StoreInst &I);
   void visitLoadInst      (LoadInst &I);
   void visitGetElementPtrInst(GetElementPtrInst &I);

llvm/trunk/lib/Transforms/Scalar/Sink.cpp

static bool isSafeToMove(Instruction *Inst, AliasAnalysis *AA,
 
   if (LoadInst *L = dyn_cast<LoadInst>(Inst)) {
     MemoryLocation Loc = MemoryLocation::get(L);
     for (Instruction *S : Stores)
       if (AA->getModRefInfo(S, Loc) & MRI_Mod)
         return false;
   }
 
-  if (isa<TerminatorInst>(Inst) || isa<PHINode>(Inst) || Inst->isEHPad())
+  if (isa<TerminatorInst>(Inst) || isa<PHINode>(Inst) || Inst->isEHPad() ||
+      Inst->mayThrow())
     return false;
 
   // Convergent operations cannot be made control-dependent on additional
   // values.
   if (auto CS = CallSite(Inst)) {
     if (CS.hasFnAttr(Attribute::Convergent))
       return false;
   }
 
   return true;
 }
 
 /// IsAcceptableTarget - Return true if it is possible to sink the instruction
 /// in the specified basic block.
 bool Sinking::IsAcceptableTarget(Instruction *Inst,
                                  BasicBlock *SuccToSinkTo) const {
   assert(Inst && "Instruction to be sunk is null");
   assert(SuccToSinkTo && "Candidate sink target is null");
 
   // It is not possible to sink an instruction into its own block.  This can
   // happen with loops.
   if (Inst->getParent() == SuccToSinkTo)
     return false;
 
+  // It's never legal to sink an instruction into a block which terminates in an
+  // EH-pad.
+  if (SuccToSinkTo->getTerminator()->isExceptional())
+    return false;
+
   // If the block has multiple predecessors, this would introduce computation
   // on different code paths.  We could split the critical edge, but for now we
   // just punt.
   // FIXME: Split critical edges if not backedges.
   if (SuccToSinkTo->getUniquePredecessor() != Inst->getParent()) {
     // We cannot sink a load across a critical edge - there may be stores in
     // other code paths.
     if (!isSafeToSpeculativelyExecute(Inst))

llvm/trunk/lib/Transforms/Utils/CodeExtractor.cpp

for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i)
           // Update the switch instruction.
           TheSwitch->addCase(ConstantInt::get(Type::getInt16Ty(Context),
                                               SuccNum),
                              OldTarget);
 
           // Restore values just before we exit
           Function::arg_iterator OAI = OutputArgBegin;
           for (unsigned out = 0, e = outputs.size(); out != e; ++out) {
-            // For an invoke/catchpad, the normal destination is the only one
-            // that is dominated by the result of the invocation
+            // For an invoke, the normal destination is the only one that is
+            // dominated by the result of the invocation
             BasicBlock *DefBlock = cast<Instruction>(outputs[out])->getParent();
 
             bool DominatesDef = true;
 
             BasicBlock *NormalDest = nullptr;
             if (auto *Invoke = dyn_cast<InvokeInst>(outputs[out]))
               NormalDest = Invoke->getNormalDest();
-            if (auto *CatchPad = dyn_cast<CatchPadInst>(outputs[out]))
-              NormalDest = CatchPad->getNormalDest();
 
             if (NormalDest) {
               DefBlock = NormalDest;
 
               // Make sure we are looking at the original successor block, not
               // at a newly inserted exit block, which won't be in the dominator
               // info.
               for (std::map<BasicBlock*, BasicBlock*>::iterator I =

llvm/trunk/lib/Transforms/Utils/InlineFunction.cpp

 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/CaptureTracking.h"
+#include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfo.h"

 HandleCallsInBlockInlinedThroughInvoke(BasicBlock *BB, BasicBlock *UnwindEdge) {
   for (BasicBlock::iterator BBI = BB->begin(), E = BB->end(); BBI != E; ) {
     Instruction *I = &*BBI++;
 
     // We only need to check for function calls: inlined invoke
     // instructions require no special handling.
     CallInst *CI = dyn_cast<CallInst>(I);
 
-    // If this call cannot unwind, don't convert it to an invoke.
-    // Inline asm calls cannot throw.
     if (!CI || CI->doesNotThrow() || isa<InlineAsm>(CI->getCalledValue()))
       continue;
 
     // Convert this function call into an invoke instruction.  First, split the
     // basic block.
     BasicBlock *Split =
         BB->splitBasicBlock(CI->getIterator(), CI->getName() + ".noexc");
 
auto UpdatePHINodes = [&](BasicBlock *Src) {
     BasicBlock::iterator I = UnwindDest->begin();
     for (Value *V : UnwindDestPHIValues) {
       PHINode *PHI = cast<PHINode>(I);
       PHI->addIncoming(V, Src);
       ++I;
     }
   };
 
-  // Forward EH terminator instructions to the caller's invoke destination.
-  // This is as simple as connect all the instructions which 'unwind to caller'
-  // to the invoke destination.
+  // This connects all the instructions which 'unwind to caller' to the invoke
+  // destination.
   for (Function::iterator BB = FirstNewBlock->getIterator(), E = Caller->end();
        BB != E; ++BB) {
-    Instruction *I = BB->getFirstNonPHI();
-    if (I->isEHPad()) {
-      if (auto *CEPI = dyn_cast<CatchEndPadInst>(I)) {
-        if (CEPI->unwindsToCaller()) {
-          CatchEndPadInst::Create(CEPI->getContext(), UnwindDest, CEPI);
-          CEPI->eraseFromParent();
-          UpdatePHINodes(&*BB);
-        }
-      } else if (auto *CEPI = dyn_cast<CleanupEndPadInst>(I)) {
-        if (CEPI->unwindsToCaller()) {
-          CleanupEndPadInst::Create(CEPI->getCleanupPad(), UnwindDest, CEPI);
-          CEPI->eraseFromParent();
-          UpdatePHINodes(&*BB);
-        }
-      } else if (auto *TPI = dyn_cast<TerminatePadInst>(I)) {
-        if (TPI->unwindsToCaller()) {
-          SmallVector<Value *, 3> TerminatePadArgs;
-          for (Value *ArgOperand : TPI->arg_operands())
-            TerminatePadArgs.push_back(ArgOperand);
-          TerminatePadInst::Create(TPI->getContext(), UnwindDest,
+    if (auto *CRI = dyn_cast<CleanupReturnInst>(BB->getTerminator())) {
+      if (CRI->unwindsToCaller()) {
+        CleanupReturnInst::Create(CRI->getCleanupPad(), UnwindDest, CRI);
+        CRI->eraseFromParent();
+
+    Instruction *I = BB->getFirstNonPHI();
+    if (!I->isEHPad())
+      continue;
+
+    Instruction *Replacement = nullptr;
+    if (auto *TPI = dyn_cast<TerminatePadInst>(I)) {
+        Replacement = TerminatePadInst::Create(TPI->getParentPad(), UnwindDest,
                                                TerminatePadArgs, TPI);
-          TPI->eraseFromParent();
-          UpdatePHINodes(&*BB);
-        }
-      } else {
-        assert(isa<CatchPadInst>(I) || isa<CleanupPadInst>(I));
-      }
-    }
-
-    if (auto *CRI = dyn_cast<CleanupReturnInst>(BB->getTerminator())) {
-      if (CRI->unwindsToCaller()) {
-        CleanupReturnInst::Create(CRI->getCleanupPad(), UnwindDest, CRI);
-        CRI->eraseFromParent();
-        UpdatePHINodes(&*BB);
-      }
-    }
-  }
+    } else if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(I)) {
+      if (CatchSwitch->unwindsToCaller()) {
+        auto *NewCatchSwitch = CatchSwitchInst::Create(
+            CatchSwitch->getParentPad(), UnwindDest,
+            CatchSwitch->getNumHandlers(), CatchSwitch->getName(),
+            CatchSwitch);
+        for (BasicBlock *PadBB : CatchSwitch->handlers())
+          NewCatchSwitch->addHandler(PadBB);
+        Replacement = NewCatchSwitch;
+      }
+    } else if (!isa<FuncletPadInst>(I)) {
+      llvm_unreachable("unexpected EHPad!");
+    }
+
+    if (Replacement) {
+      Replacement->takeName(I);
+      I->replaceAllUsesWith(Replacement);
+      I->eraseFromParent();
 
   if (InlinedCodeInfo.ContainsCalls)
     for (Function::iterator BB = FirstNewBlock->getIterator(),
                             E = Caller->end();
          BB != E; ++BB)
       if (BasicBlock *NewBB =
               HandleCallsInBlockInlinedThroughInvoke(&*BB, UnwindDest))
         // Update any PHI nodes in the exceptional block to indicate that there
if (CalledPersonality) {
     // If the personality functions match, then we can perform the
     // inlining. Otherwise, we can't inline.
     // TODO: This isn't 100% true. Some personality functions are proper
     //       supersets of others and can be used in place of the other.
     else if (CalledPersonality != CallerPersonality)
       return false;
   }
 
+  // We need to figure out which funclet the callsite was in so that we may
+  // properly nest the callee.
+  Instruction *CallSiteEHPad = nullptr;
+  if (CalledPersonality && CallerPersonality) {
+    EHPersonality Personality = classifyEHPersonality(CalledPersonality);
+    if (isFuncletEHPersonality(Personality)) {
+      DenseMap<BasicBlock *, ColorVector> CallerBlockColors =
+          colorEHFunclets(*Caller);
+      ColorVector &CallSiteColors = CallerBlockColors[OrigBB];
+      size_t NumColors = CallSiteColors.size();
+      // There is no single parent, inlining will not succeed.
+      if (NumColors > 1)
+        return false;
+      if (NumColors == 1) {
+        BasicBlock *CallSiteFuncletBB = CallSiteColors.front();
+        if (CallSiteFuncletBB != Caller->begin()) {
+          CallSiteEHPad = CallSiteFuncletBB->getFirstNonPHI();
+          assert(CallSiteEHPad->isEHPad() && "Expected an EHPad!");
+        }
+      }
+
+      // OK, the inlining site is legal.  What about the target function?
+
+      if (CallSiteEHPad) {
+        if (Personality == EHPersonality::MSVC_CXX) {
+          // The MSVC personality cannot tolerate catches getting inlined into
+          // cleanup funclets.
+          if (isa<CleanupPadInst>(CallSiteEHPad)) {
+            // Ok, the call site is within a cleanuppad.  Let's check the callee
+            // for catchpads.
+            for (const BasicBlock &CalledBB : *CalledFunc) {
+              if (isa<CatchPadInst>(CalledBB.getFirstNonPHI()))
+                return false;
+            }
+          }
+        } else if (isAsynchronousEHPersonality(Personality)) {
+          // SEH is even less tolerant, there may not be any sort of exceptional
+          // funclet in the callee.
+          for (const BasicBlock &CalledBB : *CalledFunc) {
+            if (CalledBB.isEHPad())
+              return false;
+          }
+        }
+      }
+    }
+  }
+
   // Get an iterator to the last basic block in the function, which will have
   // the new function inlined after it.
   Function::iterator LastBlock = --Caller->end();
 
   // Make sure to capture all of the return instructions from the cloned
   // function.
   SmallVector<ReturnInst*, 8> Returns;
   ClonedCodeInfo InlinedFunctionInfo;
for (ReturnInst *RI : Returns) {
       // Don't insert llvm.stackrestore calls between a musttail call and a
       // return.  The return will restore the stack pointer.
       if (InlinedMustTailCalls && RI->getParent()->getTerminatingMustTailCall())
         continue;
       IRBuilder<>(RI).CreateCall(StackRestore, SavedPtr);
     }
   }
 
+  // Update the lexical scopes of the new funclets.  Anything that had 'none' as
+  // its parent is now nested inside the callsite's EHPad.
+  if (CallSiteEHPad) {
+    for (Function::iterator BB = FirstNewBlock->getIterator(),
+                            E = Caller->end();
+         BB != E; ++BB) {
+      Instruction *I = BB->getFirstNonPHI();
+      if (!I->isEHPad())
+        continue;
+
+      if (auto *TPI = dyn_cast<TerminatePadInst>(I)) {
+        if (isa<ConstantTokenNone>(TPI->getParentPad()))
+          TPI->setParentPad(CallSiteEHPad);
+      } else if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(I)) {
+        if (isa<ConstantTokenNone>(CatchSwitch->getParentPad()))
+          CatchSwitch->setParentPad(CallSiteEHPad);
+      } else {
+        auto *FPI = cast<FuncletPadInst>(I);
+        if (isa<ConstantTokenNone>(FPI->getParentPad()))
+          FPI->setParentPad(CallSiteEHPad);
+      }
+    }
+  }
+
   // If we are inlining for an invoke instruction, we must make sure to rewrite
   // any call instructions into invoke instructions.
   if (auto *II = dyn_cast<InvokeInst>(TheCall)) {
     BasicBlock *UnwindDest = II->getUnwindDest();
     Instruction *FirstNonPHI = UnwindDest->getFirstNonPHI();
     if (isa<LandingPadInst>(FirstNonPHI)) {
       HandleInlinedLandingPad(II, &*FirstNewBlock, InlinedFunctionInfo);
     } else {

llvm/trunk/lib/Transforms/Utils/LCSSA.cpp

static bool processInstruction(Loop &L, Instruction &Inst, DominatorTree &DT,
   }
 
   // If there are no uses outside the loop, exit with no change.
   if (UsesToRewrite.empty())
     return false;
 
   ++NumLCSSA; // We are applying the transformation
 
-  // Invoke/CatchPad instructions are special in that their result value is not
-  // available along their unwind edge. The code below tests to see whether
-  // DomBB dominates the value, so adjust DomBB to the normal destination block,
+  // Invoke instructions are special in that their result value is not available
+  // along their unwind edge. The code below tests to see whether DomBB
+  // dominates the value, so adjust DomBB to the normal destination block,
   // which is effectively where the value is first usable.
   BasicBlock *DomBB = Inst.getParent();
   if (InvokeInst *Inv = dyn_cast<InvokeInst>(&Inst))
     DomBB = Inv->getNormalDest();
-  if (auto *CPI = dyn_cast<CatchPadInst>(&Inst))
-    DomBB = CPI->getNormalDest();
 
   DomTreeNode *DomNode = DT.getNode(DomBB);
 
   SmallVector<PHINode *, 16> AddedPHIs;
   SmallVector<PHINode *, 8> PostProcessPHIs;
 
   SSAUpdater SSAUpdate;
   SSAUpdate.Initialize(Inst.getType(), Inst.getName());

llvm/trunk/lib/Transforms/Utils/Local.cpp

void llvm::removeUnwindEdge(BasicBlock *BB) {
   }
 
   TerminatorInst *NewTI;
   BasicBlock *UnwindDest;
 
   if (auto *CRI = dyn_cast<CleanupReturnInst>(TI)) {
     NewTI = CleanupReturnInst::Create(CRI->getCleanupPad(), nullptr, CRI);
     UnwindDest = CRI->getUnwindDest();
-  } else if (auto *CEP = dyn_cast<CleanupEndPadInst>(TI)) {
-    NewTI = CleanupEndPadInst::Create(CEP->getCleanupPad(), nullptr, CEP);
-    UnwindDest = CEP->getUnwindDest();
-  } else if (auto *CEP = dyn_cast<CatchEndPadInst>(TI)) {
-    NewTI = CatchEndPadInst::Create(CEP->getContext(), nullptr, CEP);
-    UnwindDest = CEP->getUnwindDest();
   } else if (auto *TPI = dyn_cast<TerminatePadInst>(TI)) {
     SmallVector<Value *, 3> TerminatePadArgs;
     for (Value *Operand : TPI->arg_operands())
       TerminatePadArgs.push_back(Operand);
-    NewTI = TerminatePadInst::Create(TPI->getContext(), nullptr,
+    NewTI = TerminatePadInst::Create(TPI->getParentPad(), nullptr,
                                      TerminatePadArgs, TPI);
     UnwindDest = TPI->getUnwindDest();
+  } else if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(TI)) {
+    auto *NewCatchSwitch = CatchSwitchInst::Create(
+        CatchSwitch->getParentPad(), nullptr, CatchSwitch->getNumHandlers(),
+        CatchSwitch->getName(), CatchSwitch);
+    for (BasicBlock *PadBB : CatchSwitch->handlers())
+      NewCatchSwitch->addHandler(PadBB);
+
+    NewTI = NewCatchSwitch;
+    UnwindDest = CatchSwitch->getUnwindDest();
   } else {
     llvm_unreachable("Could not find unwind successor");
   }
 
   NewTI->takeName(TI);
   NewTI->setDebugLoc(TI->getDebugLoc());
   UnwindDest->removePredecessor(BB);
+  TI->replaceAllUsesWith(NewTI);
   TI->eraseFromParent();
 }
 
 /// removeUnreachableBlocksFromFn - Remove blocks that are not reachable, even
 /// if they are in a dead cycle.  Return true if a change was made, false
 /// otherwise.
 bool llvm::removeUnreachableBlocks(Function &F) {
   SmallPtrSet<BasicBlock*, 128> Reachable;

llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp

bool SimplifyCFGOpt::SimplifyCleanupReturn(CleanupReturnInst *RI) {
   // eliminated.  If the cleanup pad continues to the caller, any predecessor
   // that is an EH pad will be updated to continue to the caller and any
   // predecessor that terminates with an invoke instruction will have its invoke
   // instruction converted to a call instruction.  If the cleanup pad being
   // simplified does not continue to the caller, each predecessor will be
   // updated to continue to the unwind destination of the cleanup pad being
   // simplified.
   BasicBlock *BB = RI->getParent();
-  Instruction *CPInst = dyn_cast<CleanupPadInst>(BB->getFirstNonPHI());
-  if (!CPInst)
+  CleanupPadInst *CPInst = RI->getCleanupPad();
+  if (CPInst->getParent() != BB)
     // This isn't an empty cleanup.
     return false;
 
   // Check that there are no other instructions except for debug intrinsics.
   BasicBlock::iterator I = CPInst->getIterator(), E = RI->getIterator();
   while (++I != E)
     if (!isa<DbgInfoIntrinsic>(I))
       return false;
 
-  // If the cleanup return we are simplifying unwinds to the caller, this
-  // will set UnwindDest to nullptr.
+  // If the cleanup return we are simplifying unwinds to the caller, this will
+  // set UnwindDest to nullptr.
   BasicBlock *UnwindDest = RI->getUnwindDest();
+  Instruction *DestEHPad = UnwindDest ? UnwindDest->getFirstNonPHI() : nullptr;
 
   // We're about to remove BB from the control flow.  Before we do, sink any
   // PHINodes into the unwind destination.  Doing this before changing the
   // control flow avoids some potentially slow checks, since we can currently
   // be certain that UnwindDest and BB have no common predecessors (since they
   // are both EH pads).
   if (UnwindDest) {
     // First, go through the PHI nodes in UnwindDest and update any nodes that
     // reference the block we are removing
     for (BasicBlock::iterator I = UnwindDest->begin(),
-                              IE = UnwindDest->getFirstNonPHI()->getIterator();
+                              IE = DestEHPad->getIterator();
          I != IE; ++I) {
       PHINode *DestPN = cast<PHINode>(I);
 
       int Idx = DestPN->getBasicBlockIndex(BB);
       // Since BB unwinds to UnwindDest, it has to be in the PHI node.
       assert(Idx != -1);
       // This PHI node has an incoming value that corresponds to a control
       // path through the cleanup pad we are removing.  If the incoming
for (BasicBlock::iterator I = UnwindDest->begin(),
         // predecessors with this value.
         for (auto *pred : predecessors(BB)) {
           DestPN->addIncoming(SrcVal, pred);
         }
       }
     }
 
     // Sink any remaining PHI nodes directly into UnwindDest.
-    Instruction *InsertPt = UnwindDest->getFirstNonPHI();
+    Instruction *InsertPt = DestEHPad;
     for (BasicBlock::iterator I = BB->begin(),
                               IE = BB->getFirstNonPHI()->getIterator();
          I != IE;) {
       // The iterator must be incremented here because the instructions are
       // being moved to another block.
       PHINode *PN = cast<PHINode>(I++);
       if (PN->use_empty())
         // If the PHI node has no uses, just leave it.  It will be erased
if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
         if (i.getCaseSuccessor() == BB) {
           BB->removePredecessor(SI->getParent());
           SI->removeCase(i);
           --i; --e;
           Changed = true;
         }
     } else if ((isa<InvokeInst>(TI) &&
                 cast<InvokeInst>(TI)->getUnwindDest() == BB) ||
-               isa<CatchEndPadInst>(TI) || isa<TerminatePadInst>(TI)) {
+               isa<TerminatePadInst>(TI) || isa<CatchSwitchInst>(TI)) {
       removeUnwindEdge(TI->getParent());
       Changed = true;
-    } else if (isa<CleanupReturnInst>(TI) || isa<CleanupEndPadInst>(TI)) {
+    } else if (isa<CleanupReturnInst>(TI)) {
       new UnreachableInst(TI->getContext(), TI);
       TI->eraseFromParent();
       Changed = true;
     }
-    // TODO: If TI is a CatchPadInst, then (BB must be its normal dest and)
-    // we can eliminate it, redirecting its preds to its unwind successor,
-    // or to the next outer handler if the removed catch is the last for its
-    // catchendpad.
+    // TODO: We can remove a catchswitch if all it's catchpads end in
+    // unreachable.
   }
 
   // If this block is now dead, remove it.
   if (pred_empty(BB) &&
       BB != &BB->getParent()->getEntryBlock()) {
     // We know there are no successors, so just nuke the block.
     BB->eraseFromParent();
     return true;

llvm/trunk/test/Assembler/invalid-OperatorConstraint.ll

-; RUN: sed -e s/.T1:// %s | not llvm-as -disable-output 2>&1 | FileCheck --check-prefix=CHECK1 %s
-; RUN: sed -e s/.T2:// %s | not llvm-as -disable-output 2>&1 | FileCheck --check-prefix=CHECK2 %s
-; RUN: sed -e s/.T3:// %s | not llvm-as -disable-output 2>&1 | FileCheck --check-prefix=CHECK3 %s
-; RUN: sed -e s/.T4:// %s | not llvm-as -disable-output 2>&1 | FileCheck --check-prefix=CHECK4 %s
-; RUN: sed -e s/.T5:// %s | not llvm-as -disable-output 2>&1 | FileCheck --check-prefix=CHECK5 %s
-; RUN: sed -e s/.T6:// %s | not llvm-as -disable-output 2>&1 | FileCheck --check-prefix=CHECK6 %s
-; RUN: sed -e s/.T7:// %s | not llvm-as -disable-output 2>&1 | FileCheck --check-prefix=CHECK7 %s
-; RUN: sed -e s/.T8:// %s | not llvm-as -disable-output 2>&1 | FileCheck --check-prefix=CHECK8 %s
-; RUN: sed -e s/.T9:// %s | not llvm-as -disable-output 2>&1 | FileCheck --check-prefix=CHECK9 %s
-
-;T1: define void @f() {
-;T1:   entry:
-;T1:     ; operator constraint requires an operator
-;T1:     catchret undef to label %entry
-;T1:     ; CHECK1: [[@LINE-1]]:15: error: Catchpad value required in this position
-;T1: }
-
-;T2: define void @f() {
-;T2:   entry:
-;T2:     %x = cleanuppad []
-;T2:     ; catchret's first operand's operator must be catchpad
-;T2:     catchret %x to label %entry
-;T2:     ; CHECK2: [[@LINE-1]]:15: error: '%x' is not a catchpad
-;T2: }
-
-;T3: define void @f() {
-;T3:   entry:
-;T3:     ; catchret's first operand's operator must be catchpad
-;T3:     ; (forward reference case)
-;T3:     catchret %x to label %next
-;T3:     ; CHECK3: [[@LINE-1]]:15: error: '%x' is not a catchpad
-;T3:   next:
-;T3:     %x = cleanuppad []
-;T3:     ret void
-;T3: }
-
-;T4: define void @f() {
-;T4:   entry:
-;T4:     ; operator constraint requires an operator
-;T4:     cleanupret undef unwind label %entry
-;T4:     ; CHECK4: [[@LINE-1]]:17: error: Cleanuppad value required in this position
-;T4: }
-
-;T5: define void @f() {
-;T5:   entry:
-;T5:     %x = catchpad []
-;T5:             to label %next unwind label %entry
-;T5:   next:
-;T5:     ; cleanupret first operand's operator must be cleanuppad
-;T5:     cleanupret %x unwind to caller
-;T5:     ; CHECK5: [[@LINE-1]]:17: error: '%x' is not a cleanuppad
-;T5: }
-
-;T6: define void @f() {
-;T6:   entry:
-;T6:     ; cleanupret's first operand's operator must be cleanuppad
-;T6:     ; (forward reference case)
-;T6:     cleanupret %x unwind label %next
-;T6:     ; CHECK6: [[@LINE-1]]:17: error: '%x' is not a cleanuppad
-;T6:   next:
-;T6:     %x = catchpad [] to label %entry unwind label %next
-;T6: }
-
-;T7: define void @f() {
-;T7:   entry:
-;T7:     ; operator constraint requires an operator
-;T7:     cleanupendpad undef unwind to caller
-;T7:     ; CHECK7: [[@LINE-1]]:20: error: Cleanuppad value required in this position
-;T7: }
-
-;T8: define void @f() {
-;T8:   entry:
-;T8:     %x = catchpad []
-;T8:             to label %next unwind label %entry
-;T8:   next:
-;T8:     ; cleanupret first operand's operator must be cleanuppad
-;T8:     cleanupendpad %x unwind label next
-;T8:     ; CHECK8: [[@LINE-1]]:20: error: '%x' is not a cleanuppad
-;T8: }
-
-;T9: define void @f() {
-;T9:   entry:
-;T9:     ; cleanupret's first operand's operator must be cleanuppad
-;T9:     ; (forward reference case)
-;T9:     cleanupendpad %x unwind label %next
-;T9:     ; CHECK9: [[@LINE-1]]:20: error: '%x' is not a cleanuppad
-;T9:   next:
-;T9:     %x = catchpad [] to label %entry unwind label %next
-;T9: }

llvm/trunk/test/Bitcode/compatibility.ll

exc:
 
   ret void
 }
 
 define i32 @instructions.win_eh.1() personality i32 -3 {
 entry:
   %arg1 = alloca i32
   %arg2 = alloca i32
-  invoke void @f.ccc() to label %normal unwind label %catchpad1
-  invoke void @f.ccc() to label %normal unwind label %catchpad2
-  invoke void @f.ccc() to label %normal unwind label %catchpad3
+  invoke void @f.ccc() to label %normal unwind label %catchswitch1
+  invoke void @f.ccc() to label %normal unwind label %catchswitch2
+  invoke void @f.ccc() to label %normal unwind label %catchswitch3
+
+catchswitch1:
+  %cs1 = catchswitch within none [label %catchpad1] unwind label %terminate.1
 
 catchpad1:
-  catchpad [] to label %normal unwind label %exn.1
-  ; CHECK: catchpad []
-  ; CHECK-NEXT: to label %normal unwind label %exn.1
+  catchpad within %cs1 []
+  br label %normal
+  ; CHECK: catchpad within %cs1 []
+  ; CHECK-NEXT: br label %normal
+
+catchswitch2:
+  %cs2 = catchswitch within none [label %catchpad2] unwind to caller
 
 catchpad2:
-  catchpad [i32* %arg1] to label %normal unwind label %exn.2
-  ; CHECK: catchpad [i32* %arg1]
-  ; CHECK-NEXT: to label %normal unwind label %exn.2
+  catchpad within %cs2 [i32* %arg1]
+  br label %normal
+  ; CHECK: catchpad within %cs2 [i32* %arg1]
+  ; CHECK-NEXT: br label %normal
+
+catchswitch3:
+  %cs3 = catchswitch within none [label %catchpad3] unwind label %cleanuppad1
 
 catchpad3:
-  catchpad [i32* %arg1, i32* %arg2] to label %normal unwind label %exn.3
-  ; CHECK: catchpad [i32* %arg1, i32* %arg2] 
-  ; CHECK-NEXT: to label %normal unwind label %exn.3
-
-exn.1:
-  catchendpad unwind label %terminate.1
-  ; CHECK: catchendpad unwind label %terminate.1
-
-exn.2:
-  catchendpad unwind to caller
-  ; CHECK: catchendpad unwind to caller
-
-exn.3:
-  catchendpad unwind label %cleanuppad1
-  ; CHECK: catchendpad unwind label %cleanuppad1
+  catchpad within %cs3 [i32* %arg1, i32* %arg2]
+  br label %normal
+  ; CHECK: catchpad within %cs3 [i32* %arg1, i32* %arg2]
+  ; CHECK-NEXT: br label %normal
 
 cleanuppad1:
-  %clean.1 = cleanuppad []
-  ; CHECK: %clean.1 = cleanuppad []
-  invoke void @f.ccc() to label %normal unwind label %cleanupendpad1
-
-cleanupendpad1:
-  cleanupendpad %clean.1 unwind label %terminate.2
-  ; CHECK: cleanupendpad %clean.1 unwind label %terminate.2
+  %clean.1 = cleanuppad within none []
+  ; CHECK: %clean.1 = cleanuppad within none []
+  invoke void @f.ccc() to label %normal unwind label %terminate.2
 
 terminate.1:
-  terminatepad [] unwind to caller
-  ; CHECK: terminatepad [] unwind to caller
+  terminatepad within none [] unwind to caller
+  ; CHECK: terminatepad within none [] unwind to caller
 
 terminate.2:
-  terminatepad [i32* %arg1] unwind label %normal.pre
-  ; CHECK: terminatepad [i32* %arg1] unwind label %normal.pre
+  terminatepad within %clean.1 [i32* %arg1] unwind label %normal.pre
+  ; CHECK: terminatepad within %clean.1 [i32* %arg1] unwind label %normal.pre
 
 normal.pre:
-  terminatepad [i32* %arg1, i32* %arg2] unwind to caller
-  ; CHECK: terminatepad [i32* %arg1, i32* %arg2] unwind to caller
+  terminatepad within %clean.1 [i32* %arg1, i32* %arg2] unwind to caller
+  ; CHECK: terminatepad within %clean.1 [i32* %arg1, i32* %arg2] unwind to caller
 
 normal:
   ret i32 0
 }
-
+;
 define i32 @instructions.win_eh.2() personality i32 -4 {
 entry:
-  invoke void @f.ccc() to label %invoke.cont unwind label %catchpad
+  invoke void @f.ccc() to label %invoke.cont unwind label %catchswitch
 
 invoke.cont:
   invoke void @f.ccc() to label %continue unwind label %cleanup
 
 cleanup:
-  %clean = cleanuppad []
-  ; CHECK: %clean = cleanuppad []
-  cleanupret %clean unwind to caller
-  ; CHECK: cleanupret %clean unwind to caller
+  %clean = cleanuppad within none []
+  ; CHECK: %clean = cleanuppad within none []
+  cleanupret from %clean unwind to caller
+  ; CHECK: cleanupret from %clean unwind to caller
+
+catchswitch:
+  %cs = catchswitch within none [label %catchpad] unwind label %terminate
 
 catchpad:
-  %catch = catchpad [] to label %body unwind label %catchend
-  ; CHECK: %catch = catchpad []
-  ; CHECK-NEXT: to label %body unwind label %catchend
+  %catch = catchpad within %cs []
+  br label %body
+  ; CHECK: %catch = catchpad within %cs []
+  ; CHECK-NEXT: br label %body
 
 body:
-  invoke void @f.ccc() to label %continue unwind label %catchend
-  catchret %catch to label %return
-  ; CHECK: catchret %catch to label %return
+  invoke void @f.ccc() to label %continue unwind label %terminate
+  catchret from %catch to label %return
+  ; CHECK: catchret from %catch to label %return
 
 return:
   ret i32 0
 
-catchend:
-  catchendpad unwind label %terminate
-  ; CHECK: catchendpad unwind label %terminate
-
 terminate:
-  terminatepad [] unwind to caller
-  ; CHECK: terminatepad [] unwind to caller
+  terminatepad within %cs [] unwind to caller
+  ; CHECK: terminatepad within %cs [] unwind to caller
 
 continue:
   ret i32 0
 }
 
 ; Instructions -- Binary Operations
 define void @instructions.binops(i8 %op1, i8 %op2) {
   ; nuw x nsw

llvm/trunk/test/CodeGen/WinEH/wineh-cloning.ll

-; RUN: opt -mtriple=x86_x64-pc-windows-msvc -S -winehprepare  < %s | FileCheck %s
+; RUN: opt -mtriple=x86_64-pc-windows-msvc -S -winehprepare  < %s | FileCheck %s
 
 declare i32 @__CxxFrameHandler3(...)
+declare i32 @__C_specific_handler(...)
 
 declare void @f()
 declare i32 @g()
 declare void @h(i32)
 declare i1 @b()
 
 
 define void @test1() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   ; %x def colors: {entry} subset of use colors; must spill
   %x = call i32 @g()
   invoke void @f()
-    to label %noreturn unwind label %catch
+    to label %noreturn unwind label %catch.switch
+catch.switch:
+  %cs = catchswitch within none [label %catch] unwind to caller
 catch:
-  catchpad []
-    to label %noreturn unwind label %endcatch
+  catchpad within %cs []
+  br label %noreturn
 noreturn:
   ; %x use colors: {entry, cleanup}
   call void @h(i32 %x)
   unreachable
-endcatch:
-  catchendpad unwind to caller
 }
 ; Need two copies of the call to @h, one under entry and one under catch.
 ; Currently we generate a load for each, though we shouldn't need one
 ; for the use in entry's copy.
 ; CHECK-LABEL: define void @test1(
 ; CHECK: entry:
 ; CHECK:   %x = call i32 @g()
 ; CHECK:   invoke void @f()
 ; CHECK:     to label %[[EntryCopy:[^ ]+]] unwind label %catch
+; CHECK: catch.switch:
+; CHECK:   %cs = catchswitch within none [label %catch] unwind to caller
 ; CHECK: catch:
-; CHECK:   catchpad []
-; CHECK-NEXT: to label %[[CatchCopy:[^ ]+]] unwind
-; CHECK: [[CatchCopy]]:
-; CHECK:   call void @h(i32 %x)
+; CHECK:   catchpad within %cs []
+; CHECK-NEXT: call void @h(i32 %x)
 ; CHECK: [[EntryCopy]]:
 ; CHECK:   call void @h(i32 %x)
 
 
 define void @test2() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   invoke void @f()
     to label %exit unwind label %cleanup
 cleanup:
-  cleanuppad []
+  cleanuppad within none []
   br label %exit
 exit:
   call void @f()
   ret void
 }
 ; Need two copies of %exit's call to @f -- the subsequent ret is only
 ; valid when coming from %entry, but on the path from %cleanup, this
 ; might be a valid call to @f which might dynamically not return.
 ; CHECK-LABEL: define void @test2(
 ; CHECK: entry:
 ; CHECK:   invoke void @f()
 ; CHECK:     to label %[[exit:[^ ]+]] unwind label %cleanup
 ; CHECK: cleanup:
-; CHECK:   cleanuppad []
+; CHECK:   cleanuppad within none []
 ; CHECK:   call void @f()
 ; CHECK-NEXT: unreachable
 ; CHECK: [[exit]]:
 ; CHECK:   call void @f()
 ; CHECK-NEXT: ret void
 
 
 define void @test3() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   invoke void @f()
-    to label %invoke.cont unwind label %catch
+    to label %invoke.cont unwind label %catch.switch
 invoke.cont:
   invoke void @f()
     to label %exit unwind label %cleanup
+catch.switch:
+  %cs = catchswitch within none [label %catch] unwind to caller
 catch:
-  catchpad [] to label %shared unwind label %endcatch
-endcatch:
-  catchendpad unwind to caller
+  catchpad within %cs []
+  br label %shared
 cleanup:
-  cleanuppad []
+  cleanuppad within none []
   br label %shared
 shared:
   call void @f()
   br label %exit
 exit:
   ret void
 }
 ; Need two copies of %shared's call to @f (similar to @test2 but
 ; the two regions here are siblings, not parent-child).
 ; CHECK-LABEL: define void @test3(
 ; CHECK:   invoke void @f()
 ; CHECK:   invoke void @f()
 ; CHECK:     to label %[[exit:[^ ]+]] unwind
 ; CHECK: catch:
-; CHECK:   catchpad []
-; CHECK-NEXT: to label %[[shared:[^ ]+]] unwind
-; CHECK: cleanup:
-; CHECK:   cleanuppad []
-; CHECK:   call void @f()
+; CHECK:   catchpad within %cs []
+; CHECK-NEXT: call void @f()
 ; CHECK-NEXT: unreachable
-; CHECK: [[shared]]:
+; CHECK: cleanup:
+; CHECK:   cleanuppad within none []
 ; CHECK:   call void @f()
 ; CHECK-NEXT: unreachable
 ; CHECK: [[exit]]:
 ; CHECK:   ret void
 
 
 define void @test4() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   invoke void @f()
-    to label %shared unwind label %catch
+    to label %shared unwind label %catch.switch
+catch.switch:
+  %cs = catchswitch within none [label %catch] unwind to caller
 catch:
-  catchpad []
-    to label %shared unwind label %endcatch
-endcatch:
-  catchendpad unwind to caller
+  catchpad within %cs []
+  br label %shared
 shared:
   %x = call i32 @g()
   %i = call i32 @g()
   %zero.trip = icmp eq i32 %i, 0
   br i1 %zero.trip, label %exit, label %loop
 loop:
   %i.loop = phi i32 [ %i, %shared ], [ %i.dec, %loop.tail ]
   %b = call i1 @b()
exit:
   call void @h(i32 %x)
   unreachable
 }
 ; Make sure we can clone regions that have internal control
 ; flow and SSA values.  Here we need two copies of everything
 ; from %shared to %exit.
 ; CHECK-LABEL: define void @test4(
 ; CHECK:  entry:
-; CHECK:    to label %[[shared_E:[^ ]+]] unwind label %catch
+; CHECK:    to label %[[shared_E:[^ ]+]] unwind label %catch.switch
 ; CHECK:  catch:
-; CHECK:    to label %[[shared_C:[^ ]+]] unwind label %endcatch
-; CHECK:  [[shared_C]]:
+; CHECK:    catchpad within %cs []
 ; CHECK:    [[x_C:%[^ ]+]] = call i32 @g()
 ; CHECK:    [[i_C:%[^ ]+]] = call i32 @g()
 ; CHECK:    [[zt_C:%[^ ]+]] = icmp eq i32 [[i_C]], 0
 ; CHECK:    br i1 [[zt_C]], label %[[exit_C:[^ ]+]], label %[[loop_C:[^ ]+]]
 ; CHECK:  [[shared_E]]:
 ; CHECK:    [[x_E:%[^ ]+]] = call i32 @g()
 ; CHECK:    [[i_E:%[^ ]+]] = call i32 @g()
 ; CHECK:    [[zt_E:%[^ ]+]] = icmp eq i32 [[i_E]], 0
 ; CHECK:    br i1 [[zt_E]], label %[[exit_E:[^ ]+]], label %[[loop_E:[^ ]+]]
 ; CHECK:  [[loop_C]]:
-; CHECK:    [[iloop_C:%[^ ]+]] = phi i32 [ [[i_C]], %[[shared_C]] ], [ [[idec_C:%[^ ]+]], %[[looptail_C:[^ ]+]] ]
+; CHECK:    [[iloop_C:%[^ ]+]] = phi i32 [ [[i_C]], %catch ], [ [[idec_C:%[^ ]+]], %[[looptail_C:[^ ]+]] ]
 ; CHECK:    [[b_C:%[^ ]+]] = call i1 @b()
 ; CHECK:    br i1 [[b_C]], label %[[left_C:[^ ]+]], label %[[right_C:[^ ]+]]
 ; CHECK:  [[loop_E]]:
 ; CHECK:    [[iloop_E:%[^ ]+]] = phi i32 [ [[i_E]], %[[shared_E]] ], [ [[idec_E:%[^ ]+]], %[[looptail_E:[^ ]+]] ]
 ; CHECK:    [[b_E:%[^ ]+]] = call i1 @b()
 ; CHECK:    br i1 [[b_E]], label %[[left_E:[^ ]+]], label %[[right_E:[^ ]+]]
 ; CHECK:  [[left_C]]:
 ; CHECK:    [[y_C:%[^ ]+]] = call i32 @g()

 ; CHECK:  [[exit_C]]:
 ; CHECK:    call void @h(i32 [[x_C]])
 ; CHECK:    unreachable
 ; CHECK:  [[exit_E]]:
 ; CHECK:    call void @h(i32 [[x_E]])
 ; CHECK:    unreachable
 
 
-define void @test5() personality i32 (...)* @__CxxFrameHandler3 {
+define void @test5() personality i32 (...)* @__C_specific_handler {
 entry:
   invoke void @f()
     to label %exit unwind label %outer
 outer:
-  %o = cleanuppad []
+  %o = cleanuppad within none []
   %x = call i32 @g()
   invoke void @f()
-    to label %outer.ret unwind label %inner
+    to label %outer.ret unwind label %catch.switch
+catch.switch:
+  %cs = catchswitch within %o [label %inner] unwind to caller
 inner:
-  %i = catchpad []
-    to label %inner.catch unwind label %inner.endcatch
-inner.catch:
-  catchret %i to label %outer.post-inner
-inner.endcatch:
-  catchendpad unwind to caller
+  %i = catchpad within %cs []
+  catchret from %i to label %outer.post-inner
 outer.post-inner:
   call void @h(i32 %x)
   br label %outer.ret
 outer.ret:
-  cleanupret %o unwind to caller
+  cleanupret from %o unwind to caller
 exit:
   ret void
 }
 ; Simple nested case (catch-inside-cleanup).  Nothing needs
 ; to be cloned.  The def and use of %x are both in %outer
 ; and so don't need to be spilled.
 ; CHECK-LABEL: define void @test5(
 ; CHECK:      outer:
 ; CHECK:        %x = call i32 @g()
 ; CHECK-NEXT:   invoke void @f()
-; CHECK-NEXT:     to label %outer.ret unwind label %inner
+; CHECK-NEXT:     to label %outer.ret unwind label %catch.switch
 ; CHECK:      inner:
-; CHECK:          to label %inner.catch unwind label %inner.endcatch
-; CHECK:      inner.catch:
-; CHECK-NEXT:   catchret %i to label %outer.post-inner
+; CHECK-NEXT:   %i = catchpad within %cs []
+; CHECK-NEXT:   catchret from %i to label %outer.post-inner
 ; CHECK:      outer.post-inner:
 ; CHECK-NEXT:   call void @h(i32 %x)
 ; CHECK-NEXT:   br label %outer.ret
 
 
-define void @test6() personality i32 (...)* @__CxxFrameHandler3 {
+define void @test6() personality i32 (...)* @__C_specific_handler {
 entry:
   invoke void @f()
     to label %invoke.cont unwind label %left
 invoke.cont:
   invoke void @f()
     to label %exit unwind label %right
 left:
-  cleanuppad []
+  cleanuppad within none []
   br label %shared
 right:
-  catchpad []
-    to label %right.catch unwind label %right.end
+  %cs = catchswitch within none [label %right.catch] unwind to caller
 right.catch:
+  catchpad within %cs []
   br label %shared
-right.end:
-  catchendpad unwind to caller
 shared:
   %x = call i32 @g()
   invoke void @f()
     to label %shared.cont unwind label %inner
 shared.cont:
   unreachable
 inner:
-  %i = cleanuppad []
+  %i = cleanuppad within none []
   call void @h(i32 %x)
-  cleanupret %i unwind label %right.end
+  cleanupret from %i unwind to caller
 exit:
   ret void
 }
-; %inner is a cleanup which appears both as a child of
-; %left and as a child of %right.  Since statically we
-; need each funclet to have a single parent, we need to
-; clone the entire %inner funclet so we can have one
-; copy under each parent.  The cleanupret in %inner
-; unwinds to the catchendpad for %right, so the copy
-; of %inner under %right should include it; the copy
-; of %inner under %left should instead have an
-; `unreachable` inserted there, but the copy under
-; %left still needs to be created because it's possible
-; the dynamic path enters %left, then enters %inner,
-; then calls @h, and that the call to @h doesn't return.
 ; CHECK-LABEL: define void @test6(
 ; CHECK:     left:
 ; CHECK:       %x.for.left = call i32 @g()
 ; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     right:
-; CHECK:       catchpad
-; CHECK:           to label %right.catch unwind label %right.end
+; CHECK:           to label %shared.cont.for.left unwind label %inner
 ; CHECK:     right.catch:
+; CHECK:       catchpad
 ; CHECK:       %x = call i32 @g()
-; CHECK:           to label %shared.cont unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     right.end:
-; CHECK:       catchendpad unwind to caller
+; CHECK:           to label %shared.cont unwind label %inner
 ; CHECK:     shared.cont:
 ; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       [[I_R:\%.+]] = cleanuppad []
-; CHECK:       call void @h(i32 %x)
-; CHECK:       cleanupret [[I_R]] unwind label %right.end
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       [[I_L:\%.+]] = cleanuppad []
-; CHECK:       call void @h(i32 %x.for.left)
-; CHECK:       unreachable
-
-
-define void @test7() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %invoke.cont unwind label %left
-invoke.cont:
-  invoke void @f()
-    to label %unreachable unwind label %right
-left:
-  cleanuppad []
-  invoke void @f() to label %unreachable unwind label %inner
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  invoke void @f() to label %unreachable unwind label %inner
-right.end:
-  catchendpad unwind to caller
-inner:
-  %i = cleanuppad []
-  %x = call i32 @g()
-  call void @h(i32 %x)
-  cleanupret %i unwind label %right.end
-unreachable:
-  unreachable
-}
-; Another case of a two-parent child (like @test6), this time
-; with the join at the entry itself instead of following a
-; non-pad join.
-; CHECK-LABEL: define void @test7(
-; CHECK:     invoke.cont:
-; CHECK:           to label %[[UNREACHABLE_ENTRY:.+]] unwind label %right
-; CHECK:     left:
-; CHECK:           to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     right:
-; CHECK:           to label %right.catch unwind label %right.end
-; CHECK:     right.catch:
-; CHECK:           to label %unreachable unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     right.end:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       [[I_R:\%.+]] = cleanuppad []
-; CHECK:       [[X_R:\%.+]] = call i32 @g()
-; CHECK:       call void @h(i32 [[X_R]])
-; CHECK:       cleanupret [[I_R]] unwind label %right.end
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       [[I_L:\%.+]] = cleanuppad []
-; CHECK:       [[X_L:\%.+]] = call i32 @g()
-; CHECK:       call void @h(i32 [[X_L]])
-; CHECK:       unreachable
-; CHECK:     unreachable:
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_ENTRY]]:
-; CHECK:       unreachable
-
-
-define void @test8() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %invoke.cont unwind label %left
-invoke.cont:
-  invoke void @f()
-    to label %unreachable unwind label %right
-left:
-  cleanuppad []
-  br label %shared
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  br label %shared
-right.end:
-  catchendpad unwind to caller
-shared:
-  invoke void @f()
-    to label %unreachable unwind label %inner
-inner:
-  cleanuppad []
-  invoke void @f()
-    to label %unreachable unwind label %inner.child
-inner.child:
-  cleanuppad []
-  %x = call i32 @g()
-  call void @h(i32 %x)
-  unreachable
-unreachable:
-  unreachable
-}
-; %inner is a two-parent child which itself has a child; need
-; to make two copies of both the %inner and %inner.child.
-; CHECK-LABEL: define void @test8(
-; CHECK:     invoke.cont:
-; CHECK:               to label %[[UNREACHABLE_ENTRY:.+]] unwind label %right
-; CHECK:     left:
-; CHECK:               to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     right:
-; CHECK:               to label %right.catch unwind label %right.end
-; CHECK:     right.catch:
-; CHECK:               to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     right.end:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:               to label %[[UNREACHABLE_INNER_RIGHT:.+]] unwind label %[[INNER_CHILD_RIGHT:.+]]
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:               to label %[[UNREACHABLE_INNER_LEFT:.+]] unwind label %[[INNER_CHILD_LEFT:.+]]
-; CHECK:     [[INNER_CHILD_RIGHT]]:
-; CHECK:       [[TMP:\%.+]] = cleanuppad []
-; CHECK:       [[X:\%.+]] = call i32 @g()
-; CHECK:       call void @h(i32 [[X]])
-; CHECK:       unreachable
-; CHECK:     [[INNER_CHILD_LEFT]]:
-; CHECK:       [[TMP:\%.+]] = cleanuppad []
-; CHECK:       [[X:\%.+]] = call i32 @g()
-; CHECK:       call void @h(i32 [[X]])
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_INNER_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_INNER_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_ENTRY]]:
+; CHECK:     shared.cont.for.left:
 ; CHECK:       unreachable
+; CHECK:     inner:
+; CHECK:       %i = cleanuppad within none []
+; CHECK:       call void @h(i32 %x1.wineh.reload)
+; CHECK:       cleanupret from %i unwind to caller
 
 
-define void @test9() personality i32 (...)* @__CxxFrameHandler3 {
+define void @test9() personality i32 (...)* @__C_specific_handler {
 entry:
   invoke void @f()
     to label %invoke.cont unwind label %left
 invoke.cont:
   invoke void @f()
     to label %unreachable unwind label %right
 left:
-  cleanuppad []
+  cleanuppad within none []
   call void @h(i32 1)
   invoke void @f()
     to label %unreachable unwind label %right
 right:
-  cleanuppad []
+  cleanuppad within none []
   call void @h(i32 2)
   invoke void @f()
     to label %unreachable unwind label %left
 unreachable:
   unreachable
 }
-; This is an irreducible loop with two funclets that enter each other;
-; need to make two copies of each funclet (one a child of root, the
-; other a child of the opposite funclet), but also make sure not to
-; clone self-descendants (if we tried to do that we'd need to make an
-; infinite number of them).  Presumably if optimizations ever generated
-; such a thing it would mean that one of the two cleanups was originally
-; the parent of the other, but that we'd somehow lost track in the CFG
-; of which was which along the way; generating each possibility lets
-; whichever case was correct execute correctly.
+; This is an irreducible loop with two funclets that enter each other.
 ; CHECK-LABEL: define void @test9(
 ; CHECK:     entry:
 ; CHECK:               to label %invoke.cont unwind label %[[LEFT:.+]]
 ; CHECK:     invoke.cont:
 ; CHECK:               to label %[[UNREACHABLE_ENTRY:.+]] unwind label %[[RIGHT:.+]]
-; CHECK:     [[LEFT_FROM_RIGHT:.+]]:
-; CHECK:       call void @h(i32 1)
-; CHECK:       call void @f()
-; CHECK:       unreachable
 ; CHECK:     [[LEFT]]:
 ; CHECK:       call void @h(i32 1)
 ; CHECK:       invoke void @f()
-; CHECK:               to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[RIGHT_FROM_LEFT:.+]]
+; CHECK:               to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[RIGHT]]
 ; CHECK:     [[RIGHT]]:
 ; CHECK:       call void @h(i32 2)
 ; CHECK:       invoke void @f()
-; CHECK:               to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[LEFT_FROM_RIGHT]]
-; CHECK:     [[RIGHT_FROM_LEFT]]:
-; CHECK:       call void @h(i32 2)
-; CHECK:       call void @f()
-; CHECK:       unreachable
+; CHECK:               to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[LEFT]]
 ; CHECK:     [[UNREACHABLE_RIGHT]]:
 ; CHECK:       unreachable
 ; CHECK:     [[UNREACHABLE_LEFT]]:
 ; CHECK:       unreachable
 ; CHECK:     [[UNREACHABLE_ENTRY]]:
 ; CHECK:       unreachable
 
 
 define void @test10() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   invoke void @f()
     to label %unreachable unwind label %inner
 inner:
-  %cleanup = cleanuppad []
+  %cleanup = cleanuppad within none []
   ; make sure we don't overlook this cleanupret and try to process
   ; successor %outer as a child of inner.
-  cleanupret %cleanup unwind label %outer
+  cleanupret from %cleanup unwind label %outer
 outer:
-  %catch = catchpad [] to label %catch.body unwind label %endpad
+  %cs = catchswitch within none [label %catch.body] unwind to caller
+
 catch.body:
-  catchret %catch to label %exit
-endpad:
-  catchendpad unwind to caller
+  %catch = catchpad within %cs []
+  catchret from %catch to label %exit
 exit:
   ret void
 unreachable:
   unreachable
 }
 ; CHECK-LABEL: define void @test10(
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT:   invoke
 ; CHECK-NEXT:     to label %unreachable unwind label %inner
 ; CHECK:      inner:
-; CHECK-NEXT:   %cleanup = cleanuppad
-; CHECK-NEXT:   cleanupret %cleanup unwind label %outer
+; CHECK-NEXT:   %cleanup = cleanuppad within none []
+; CHECK-NEXT:   cleanupret from %cleanup unwind label %outer
 ; CHECK:      outer:
-; CHECK-NEXT:   %catch = catchpad []
-; CHECK-NEXT:       to label %catch.body unwind label %endpad
+; CHECK-NEXT:   %cs = catchswitch within none [label %catch.body] unwind to caller
 ; CHECK:      catch.body:
-; CHECK-NEXT:   catchret %catch to label %exit
-; CHECK:      endpad:
-; CHECK-NEXT:   catchendpad unwind to caller
+; CHECK-NEXT:   %catch = catchpad within %cs []
+; CHECK-NEXT:   catchret from %catch to label %exit
 ; CHECK:      exit:
 ; CHECK-NEXT:   ret void
 
-define void @test11() personality i32 (...)* @__CxxFrameHandler3 {
+define void @test11() personality i32 (...)* @__C_specific_handler {
 entry:
   invoke void @f()
     to label %exit unwind label %cleanup.outer
 cleanup.outer:
-  %outer = cleanuppad []
+  %outer = cleanuppad within none []
   invoke void @f()
     to label %outer.cont unwind label %cleanup.inner
 outer.cont:
   br label %merge
 cleanup.inner:
-  %inner = cleanuppad []
+  %inner = cleanuppad within %outer []
   br label %merge
 merge:
-  invoke void @f()
-    to label %unreachable unwind label %merge.end
-unreachable:
+  call void @f()
   unreachable
-merge.end:
-  cleanupendpad %outer unwind to caller
 exit:
   ret void
 }
 ; merge.end will get cloned for outer and inner, but is implausible
-; from inner, so the invoke @f() in inner's copy of merge should be
+; from inner, so the call @f() in inner's copy of merge should be
 ; rewritten to call @f()
 ; CHECK-LABEL: define void @test11()
-; CHECK:      %inner = cleanuppad []
+; CHECK:      %inner = cleanuppad within %outer []
 ; CHECK-NEXT: call void @f()
 ; CHECK-NEXT: unreachable
 
 define void @test12() personality i32 (...)* @__CxxFrameHandler3 !dbg !5 {
 entry:
   invoke void @f()
     to label %cont unwind label %left, !dbg !8
 cont:
   invoke void @f()
     to label %exit unwind label %right
 left:
-  cleanuppad []
+  cleanuppad within none []
   br label %join
 right:
-  cleanuppad []
+  cleanuppad within none []
   br label %join
 join:
   ; This call will get cloned; make sure we can handle cloning
   ; instructions with debug metadata attached.
   call void @f(), !dbg !9
   unreachable
 exit:
   ret void
 }
 
 ; CHECK-LABEL: define void @test13()
 ; CHECK: ret void
 define void @test13() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   ret void
 
 unreachable:
-  cleanuppad []
+  cleanuppad within none []
   unreachable
 }
 
-define void @test14() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %exit unwind label %catch1.pad
-catch1.pad:
-  %catch1 = catchpad [i32 1]
-    to label %catch1.body unwind label %catch2.pad
-catch1.body:
-  invoke void @h(i32 1)
-    to label %catch1.body2 unwind label %catch.end
-catch1.body2:
-  invoke void @f()
-    to label %catch1.ret unwind label %cleanup1.pad
-cleanup1.pad:
-  %cleanup1 = cleanuppad []
-  call void @f()
-  cleanupret %cleanup1 unwind label %catch.end
-catch1.ret:
-  catchret %catch1 to label %exit
-catch2.pad:
-  %catch2 = catchpad [i32 2]
-    to label %catch2.body unwind label %catch.end
-catch2.body:
-  invoke void @h(i32 2)
-    to label %catch2.body2 unwind label %catch.end
-catch2.body2:
-  invoke void @f()
-    to label %catch2.ret unwind label %cleanup2.pad
-cleanup2.pad:
-  %cleanup2 = cleanuppad []
-  call void @f()
-  cleanupret %cleanup2 unwind label %catch.end
-catch2.ret:
-  catchret %catch2 to label %exit
-catch.end:
-  catchendpad unwind to caller
-exit:
-  ret void
-}
-; Make sure we don't clone the catchendpad even though the
-; cleanupendpads targeting it would naively imply that it
-; should get their respective parent colors (catch1 and catch2),
-; as well as its properly getting the root function color.  The
-; references from the invokes ensure that if we did make clones
-; for each catch, they'd be reachable, as those invokes would get
-; rewritten
-; CHECK-LABEL: define void @test14()
-; CHECK-NOT:  catchendpad
-; CHECK:      invoke void @h(i32 1)
-; CHECK-NEXT:   unwind label %catch.end
-; CHECK-NOT:  catchendpad
-; CHECK:      invoke void @h(i32 2)
-; CHECK-NEXT:   unwind label %catch.end
-; CHECK-NOT:   catchendpad
-; CHECK:     catch.end:
-; CHECK-NEXT:  catchendpad
-; CHECK-NOT:   catchendpad
-
 ;; Debug info (from test12)
 
 ; Make sure the DISubprogram doesn't get cloned
 ; CHECK-LABEL: !llvm.module.flags
 ; CHECK-NOT: !DISubprogram
 ; CHECK: !{{[0-9]+}} = distinct !DISubprogram(name: "test12"
 ; CHECK-NOT: !DISubprogram
 !llvm.module.flags = !{!0}

llvm/trunk/test/CodeGen/WinEH/wineh-coreclr.ll

-; RUN: llc -mtriple=x86_64-pc-windows-coreclr -verify-machineinstrs < %s | FileCheck %s
-
-declare void @ProcessCLRException()
-declare void @f(i32)
-declare void @g(i8 addrspace(1)*)
-declare i8 addrspace(1)* @llvm.eh.exceptionpointer.p1i8(token)
-
-; Simplified IR for pseudo-C# like the following:
-; void test1() {
-;   try {
-;     f(1);
-;     try {
-;       f(2);
-;     } catch (type1) {
-;       f(3);
-;     } catch (type2) [
-;       f(4);
-;       try {
-;         f(5);
-;       } fault {
-;         f(6);
-;       }
-;     }
-;   } finally {
-;     f(7);
-;   }
-;   f(8);
-; }
-
-; CHECK-LABEL: test1:     # @test1
-; CHECK-NEXT: [[L_begin:.*func_begin.*]]:
-define void @test1() personality i8* bitcast (void ()* @ProcessCLRException to i8*) {
-entry:
-; CHECK: # %entry
-; CHECK: leaq [[FPOffset:[0-9]+]](%rsp), %rbp
-; CHECK: .seh_endprologue
-; CHECK: movq %rsp, [[PSPSymOffset:[0-9]+]](%rsp)
-; CHECK: [[L_before_f1:.+]]:
-; CHECK-NEXT: movl $1, %ecx
-; CHECK-NEXT: callq f
-; CHECK-NEXT: [[L_after_f1:.+]]:
-  invoke void @f(i32 1)
-    to label %inner_try unwind label %finally.pad
-inner_try:
-; CHECK: # %inner_try
-; CHECK: [[L_before_f2:.+]]:
-; CHECK-NEXT: movl $2, %ecx
-; CHECK-NEXT: callq f
-; CHECK-NEXT: [[L_after_f2:.+]]:
-  invoke void @f(i32 2)
-    to label %finally.clone unwind label %catch1.pad
-catch1.pad:
-; CHECK: .seh_proc [[L_catch1:[^ ]+]]
-  %catch1 = catchpad [i32 1]
-    to label %catch1.body unwind label %catch2.pad
-catch1.body:
-; CHECK: .seh_stackalloc [[FuncletFrameSize:[0-9]+]]
-;                        ^ all funclets use the same frame size
-; CHECK: movq [[PSPSymOffset]](%rcx), %rcx
-;                              ^ establisher frame pointer passed in rcx
-; CHECK: movq %rcx, [[PSPSymOffset]](%rsp)
-; CHECK: leaq [[FPOffset]](%rcx), %rbp
-; CHECK: .seh_endprologue
-; CHECK: movq %rdx, %rcx
-;             ^ exception pointer passed in rdx
-; CHECK-NEXT: callq g
-  %exn1 = call i8 addrspace(1)* @llvm.eh.exceptionpointer.p1i8(token %catch1)
-  call void @g(i8 addrspace(1)* %exn1)
-; CHECK: [[L_before_f3:.+]]:
-; CHECK-NEXT: movl $3, %ecx
-; CHECK-NEXT: callq f
-; CHECK-NEXT: [[L_after_f3:.+]]:
-  invoke void @f(i32 3)
-    to label %catch1.ret unwind label %catch.end
-catch1.ret:
-  catchret %catch1 to label %finally.clone
-catch2.pad:
-; CHECK: .seh_proc [[L_catch2:[^ ]+]]
-  %catch2 = catchpad [i32 2]
-    to label %catch2.body unwind label %catch.end
-catch2.body:
-; CHECK: .seh_stackalloc [[FuncletFrameSize:[0-9]+]]
-;                        ^ all funclets use the same frame size
-; CHECK: movq [[PSPSymOffset]](%rcx), %rcx
-;                              ^ establisher frame pointer passed in rcx
-; CHECK: movq %rcx, [[PSPSymOffset]](%rsp)
-; CHECK: leaq [[FPOffset]](%rcx), %rbp
-; CHECK: .seh_endprologue
-; CHECK: movq %rdx, %rcx
-;             ^ exception pointer passed in rdx
-; CHECK-NEXT: callq g
-  %exn2 = call i8 addrspace(1)* @llvm.eh.exceptionpointer.p1i8(token %catch2)
-  call void @g(i8 addrspace(1)* %exn2)
-; CHECK: [[L_before_f4:.+]]:
-; CHECK-NEXT: movl $4, %ecx
-; CHECK-NEXT: callq f
-; CHECK-NEXT: [[L_after_f4:.+]]:
-  invoke void @f(i32 4)
-    to label %try_in_catch unwind label %catch.end
-try_in_catch:
-; CHECK: # %try_in_catch
-; CHECK: [[L_before_f5:.+]]:
-; CHECK-NEXT: movl $5, %ecx
-; CHECK-NEXT: callq f
-; CHECK-NEXT: [[L_after_f5:.+]]:
-  invoke void @f(i32 5)
-    to label %catch2.ret unwind label %fault.pad
-fault.pad:
-; CHECK: .seh_proc [[L_fault:[^ ]+]]
-  %fault = cleanuppad [i32 undef]
-; CHECK: .seh_stackalloc [[FuncletFrameSize:[0-9]+]]
-;                        ^ all funclets use the same frame size
-; CHECK: movq [[PSPSymOffset]](%rcx), %rcx
-;                              ^ establisher frame pointer passed in rcx
-; CHECK: movq %rcx, [[PSPSymOffset]](%rsp)
-; CHECK: leaq [[FPOffset]](%rcx), %rbp
-; CHECK: .seh_endprologue
-; CHECK: [[L_before_f6:.+]]:
-; CHECK-NEXT: movl $6, %ecx
-; CHECK-NEXT: callq f
-; CHECK-NEXT: [[L_after_f6:.+]]:
-  invoke void @f(i32 6)
-    to label %fault.ret unwind label %fault.end
-fault.ret:
-  cleanupret %fault unwind label %catch.end
-fault.end:
-  cleanupendpad %fault unwind label %catch.end
-catch2.ret:
-  catchret %catch2 to label %finally.clone
-catch.end:
-  catchendpad unwind label %finally.pad
-finally.clone:
-  call void @f(i32 7)
-  br label %tail
-finally.pad:
-; CHECK: .seh_proc [[L_finally:[^ ]+]]
-  %finally = cleanuppad []
-; CHECK: .seh_stackalloc [[FuncletFrameSize:[0-9]+]]
-;                        ^ all funclets use the same frame size
-; CHECK: movq [[PSPSymOffset]](%rcx), %rcx
-;                              ^ establisher frame pointer passed in rcx
-; CHECK: movq %rcx, [[PSPSymOffset]](%rsp)
-; CHECK: leaq [[FPOffset]](%rcx), %rbp
-; CHECK: .seh_endprologue
-; CHECK: [[L_before_f7:.+]]:
-; CHECK-NEXT: movl $7, %ecx
-; CHECK-NEXT: callq f
-; CHECK-NEXT: [[L_after_f7:.+]]:
-  invoke void @f(i32 7)
-    to label %finally.ret unwind label %finally.end
-finally.ret:
-  cleanupret %finally unwind to caller
-finally.end:
-   cleanupendpad %finally unwind to caller
-tail:
-  call void @f(i32 8)
-  ret void
-; CHECK: [[L_end:.*func_end.*]]:
-}
-
-; Now check for EH table in xdata (following standard xdata)
-; CHECK-LABEL: .section .xdata
-; standard xdata comes here
-; CHECK:      .long 4{{$}}
-;                   ^ number of funclets
-; CHECK-NEXT: .long [[L_catch1]]-[[L_begin]]
-;                   ^ offset from L_begin to start of 1st funclet
-; CHECK-NEXT: .long [[L_catch2]]-[[L_begin]]
-;                   ^ offset from L_begin to start of 2nd funclet
-; CHECK-NEXT: .long [[L_fault]]-[[L_begin]]
-;                   ^ offset from L_begin to start of 3rd funclet
-; CHECK-NEXT: .long [[L_finally]]-[[L_begin]]
-;                   ^ offset from L_begin to start of 4th funclet
-; CHECK-NEXT: .long [[L_end]]-[[L_begin]]
-;                   ^ offset from L_begin to end of last funclet
-; CHECK-NEXT: .long 7
-;                   ^ number of EH clauses
-; Clause 1: call f(2) is guarded by catch1
-; CHECK-NEXT: .long 0
-;                   ^ flags (0 => catch handler)
-; CHECK-NEXT: .long ([[L_before_f2]]-[[L_begin]])+1
-;                   ^ offset of start of clause
-; CHECK-NEXT: .long ([[L_after_f2]]-[[L_begin]])+1
-;                   ^ offset of end of clause
-; CHECK-NEXT: .long [[L_catch1]]-[[L_begin]]
-;                   ^ offset of start of handler
-; CHECK-NEXT: .long [[L_catch2]]-[[L_begin]]
-;                   ^ offset of end of handler
-; CHECK-NEXT: .long 1
-;                   ^ type token of catch (from catchpad)
-; Clause 2: call f(2) is also guarded by catch2
-; CHECK-NEXT: .long 0
-;                   ^ flags (0 => catch handler)
-; CHECK-NEXT: .long ([[L_before_f2]]-[[L_begin]])+1
-;                   ^ offset of start of clause
-; CHECK-NEXT: .long ([[L_after_f2]]-[[L_begin]])+1
-;                   ^ offset of end of clause
-; CHECK-NEXT: .long [[L_catch2]]-[[L_begin]]
-;                   ^ offset of start of handler
-; CHECK-NEXT: .long [[L_fault]]-[[L_begin]]
-;                   ^ offset of end of handler
-; CHECK-NEXT: .long 2
-;                   ^ type token of catch (from catchpad)
-; Clause 3: calls f(1) and f(2) are guarded by finally
-; CHECK-NEXT: .long 2
-;                   ^ flags (2 => finally handler)
-; CHECK-NEXT: .long ([[L_before_f1]]-[[L_begin]])+1
-;                   ^ offset of start of clause
-; CHECK-NEXT: .long ([[L_after_f2]]-[[L_begin]])+1
-;                   ^ offset of end of clause
-; CHECK-NEXT: .long [[L_finally]]-[[L_begin]]
-;                   ^ offset of start of handler
-; CHECK-NEXT: .long [[L_end]]-[[L_begin]]
-;                   ^ offset of end of handler
-; CHECK-NEXT: .long 0
-;                   ^ type token slot (null for finally)
-; Clause 4: call f(3) is guarded by finally
-;           This is a "duplicate" because the protected range (f(3))
-;           is in funclet catch1 but the finally's immediate parent
-;           is the main function, not that funclet.
-; CHECK-NEXT: .long 10
-;                   ^ flags (2 => finally handler | 8 => duplicate)
-; CHECK-NEXT: .long ([[L_before_f3]]-[[L_begin]])+1
-;                   ^ offset of start of clause
-; CHECK-NEXT: .long ([[L_after_f3]]-[[L_begin]])+1
-;                   ^ offset of end of clause
-; CHECK-NEXT: .long [[L_finally]]-[[L_begin]]
-;                   ^ offset of start of handler
-; CHECK-NEXT: .long [[L_end]]-[[L_begin]]
-;                   ^ offset of end of handler
-; CHECK-NEXT: .long 0
-;                   ^ type token slot (null for finally)
-; Clause 5: call f(5) is guarded by fault
-; CHECK-NEXT: .long 4
-;                   ^ flags (4 => fault handler)
-; CHECK-NEXT: .long ([[L_before_f5]]-[[L_begin]])+1
-;                   ^ offset of start of clause
-; CHECK-NEXT: .long ([[L_after_f5]]-[[L_begin]])+1
-;                   ^ offset of end of clause
-; CHECK-NEXT: .long [[L_fault]]-[[L_begin]]
-;                   ^ offset of start of handler
-; CHECK-NEXT: .long [[L_finally]]-[[L_begin]]
-;                   ^ offset of end of handler
-; CHECK-NEXT: .long 0
-;                   ^ type token slot (null for fault)
-; Clause 6: calls f(4) and f(5) are guarded by finally
-;           This is a "duplicate" because the protected range (f(4)-f(5))
-;           is in funclet catch2 but the finally's immediate parent
-;           is the main function, not that funclet.
-; CHECK-NEXT: .long 10
-;                   ^ flags (2 => finally handler | 8 => duplicate)
-; CHECK-NEXT: .long ([[L_before_f4]]-[[L_begin]])+1
-;                   ^ offset of start of clause
-; CHECK-NEXT: .long ([[L_after_f5]]-[[L_begin]])+1
-;                   ^ offset of end of clause
-; CHECK-NEXT: .long [[L_finally]]-[[L_begin]]
-;                   ^ offset of start of handler
-; CHECK-NEXT: .long [[L_end]]-[[L_begin]]
-;                   ^ offset of end of handler
-; CHECK-NEXT: .long 0
-;                   ^ type token slot (null for finally)
-; Clause 7: call f(6) is guarded by finally
-;           This is a "duplicate" because the protected range (f(3))
-;           is in funclet catch1 but the finally's immediate parent
-;           is the main function, not that funclet.
-; CHECK-NEXT: .long 10
-;                   ^ flags (2 => finally handler | 8 => duplicate)
-; CHECK-NEXT: .long ([[L_before_f6]]-[[L_begin]])+1
-;                   ^ offset of start of clause
-; CHECK-NEXT: .long ([[L_after_f6]]-[[L_begin]])+1
-;                   ^ offset of end of clause
-; CHECK-NEXT: .long [[L_finally]]-[[L_begin]]
-;                   ^ offset of start of handler
-; CHECK-NEXT: .long [[L_end]]-[[L_begin]]
-;                   ^ offset of end of handler
-; CHECK-NEXT: .long 0
-;                   ^ type token slot (null for finally)

llvm/trunk/test/CodeGen/WinEH/wineh-demotion.ll

-; RUN: opt -mtriple=x86_x64-pc-windows-msvc -S -winehprepare  < %s | FileCheck %s
+; RUN: opt -mtriple=x86_64-pc-windows-msvc -S -winehprepare  < %s | FileCheck %s
 
 declare i32 @__CxxFrameHandler3(...)
 
 declare void @f()
 
 declare i32 @g()
 
 declare void @h(i32)
right:
   ; CHECK-NEXT: store i32 %y, i32* [[Slot]]
   ; CHECK-NEXT: invoke void @f
   invoke void @f()
           to label %exit unwind label %merge
 merge:
   ; CHECK: merge:
   ; CHECK-NOT: = phi
   %phi = phi i32 [ %x, %left ], [ %y, %right ]
-  %cp = catchpad [] to label %catch unwind label %catchend
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:
+  %cp = catchpad within %cs1 []
   ; CHECK: catch:
   ; CHECK: [[Reload:%[^ ]+]] = load i32, i32* [[Slot]]
   ; CHECK-NEXT: call void @h(i32 [[Reload]])
   call void @h(i32 %phi)
-  catchret %cp to label %exit
-
-catchend:
-  catchendpad unwind to caller
+  catchret from %cp to label %exit
 
 exit:
   ret void
 }
 
 ; CHECK-LABEL: @test2(
 define void @test2(i1 %B) personality i32 (...)* @__CxxFrameHandler3 {
 entry:
right:
   ; CHECK-DAG:   store i32 2, i32* [[Slot1]]
   ; CHECK-DAG:   store i32 2, i32* [[Slot2]]
   ; CHECK: invoke void @f
   invoke void @f()
           to label %exit unwind label %merge.inner
 merge.inner:
   ; CHECK: merge.inner:
   ; CHECK-NOT: = phi
-  ; CHECK: catchpad []
+  ; CHECK: catchswitch within none
   %x = phi i32 [ 1, %left ], [ 2, %right ]
-  %cpinner = catchpad [] to label %catch.inner unwind label %catchend.inner
+  %cs1 = catchswitch within none [label %catch.inner] unwind label %merge.outer
 
 catch.inner:
+  %cpinner = catchpad within %cs1 []
   ; Need just one store here because only %y is affected
   ; CHECK: catch.inner:
   %z = call i32 @g()
   ; CHECK:   store i32 %z
   ; CHECK-NEXT: invoke void @f
   invoke void @f()
-          to label %catchret.inner unwind label %catchend.inner
+          to label %catchret.inner unwind label %merge.outer
 
 catchret.inner:
-  catchret %cpinner to label %exit
-catchend.inner:
-  ; CHECK-NOT: = phi
-  %y = phi i32 [ %x, %merge.inner ], [ %z, %catch.inner ]
-  catchendpad unwind label %merge.outer
+  catchret from %cpinner to label %exit
 
 merge.outer:
+  %y = phi i32 [ %x, %merge.inner ], [ %z, %catch.inner ]
   ; CHECK: merge.outer:
-  ; CHECK: [[CatchPad:%[^ ]+]] = catchpad []
-  %cpouter = catchpad [] to label %catch.outer unwind label %catchend.outer
-
-catchend.outer:
-  catchendpad unwind to caller
+  ; CHECK-NOT: = phi
+  ; CHECK: catchswitch within none
+  %cs2 = catchswitch within none [label %catch.outer] unwind to caller
 
 catch.outer:
+  %cpouter = catchpad within %cs2 []
+  ; CHECK: catch.outer:
+  ; CHECK: [[CatchPad:%[^ ]+]] = catchpad within %cs2 []
   ; Need to load x and y from two different slots since they're both live
   ; and can have different values (if we came from catch.inner)
-  ; CHECK: catch.outer:
   ; CHECK-DAG: load i32, i32* [[Slot1]]
   ; CHECK-DAG: load i32, i32* [[Slot2]]
-  ; CHECK: catchret [[CatchPad]] to label
+  ; CHECK: catchret from [[CatchPad]] to label
   call void @h(i32 %x)
   call void @h(i32 %y)
-  catchret %cpouter to label %exit
+  catchret from %cpouter to label %exit
 
 exit:
   ret void
 }
 
 ; test4: don't need stores for %phi.inner, as its only use is to feed %phi.outer
 ;        %phi.outer needs stores in %left, %right, and %join
 ; CHECK-LABEL: @test4(
right:
   ; CHECK-NOT: store
   ; CHECK: store i32 %r, i32* [[Slot]]
   ; CHECK-NEXT: invoke void @f
   %r = call i32 @g()
   invoke void @f()
           to label %join unwind label %catchpad.inner
 catchpad.inner:
    ; CHECK: catchpad.inner:
-   ; CHECK-NEXT: catchpad []
+   ; CHECK-NEXT: catchswitch within none
    %phi.inner = phi i32 [ %l, %left ], [ %r, %right ]
-   %cp1 = catchpad [] to label %catch.inner unwind label %catchend.inner
+   %cs1 = catchswitch within none [label %catch.inner] unwind label %catchpad.outer
 catch.inner:
-   catchret %cp1 to label %join
-catchend.inner:
-   catchendpad unwind label  %catchpad.outer
+   %cp1 = catchpad within %cs1 []
+   catchret from %cp1 to label %join
 join:
   ; CHECK: join:
   ; CHECK-NOT: store
   ; CHECK: store i32 %j, i32* [[Slot]]
   ; CHECK-NEXT: invoke void @f
    %j = call i32 @g()
    invoke void @f()
            to label %exit unwind label %catchpad.outer
+
 catchpad.outer:
    ; CHECK: catchpad.outer:
-   ; CHECK-NEXT: catchpad []
-   %phi.outer = phi i32 [ %phi.inner, %catchend.inner ], [ %j, %join ]
-   %cp2 = catchpad [] to label %catch.outer unwind label %catchend.outer
+   ; CHECK-NEXT: catchswitch within none
+   %phi.outer = phi i32 [ %phi.inner, %catchpad.inner ], [ %j, %join ]
+   %cs2 = catchswitch within none [label %catch.outer] unwind to caller
 catch.outer:
    ; CHECK: catch.outer:
    ; CHECK:   [[Reload:%[^ ]+]] = load i32, i32* [[Slot]]
    ; CHECK:   call void @h(i32 [[Reload]])
+   %cp2 = catchpad within %cs2 []
    call void @h(i32 %phi.outer)
-   catchret %cp2 to label %exit
-catchend.outer:
-   catchendpad unwind to caller
+   catchret from %cp2 to label %exit
 exit:
    ret void
 }
 
 ; CHECK-LABEL: @test5(
 define void @test5() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   ; need store for %phi.cleanup
invoke.cont:
   ; CHECK-NEXT:   store i32 2, i32* [[CleanupSlot]]
   ; CHECK-NEXT:   invoke void @f
   invoke void @f()
           to label %invoke.cont2 unwind label %cleanup
 
 cleanup:
   ; cleanup phi can be loaded at cleanup entry
   ; CHECK: cleanup:
-  ; CHECK-NEXT: cleanuppad []
+  ; CHECK-NEXT: cleanuppad within none []
   ; CHECK: [[CleanupReload:%[^ ]+]] = load i32, i32* [[CleanupSlot]]
   %phi.cleanup = phi i32 [ 1, %entry ], [ 2, %invoke.cont ]
-  %cp = cleanuppad []
+  %cp = cleanuppad within none []
   %b = call i1 @i()
   br i1 %b, label %left, label %right
 
 left:
   ; CHECK: left:
   ; CHECK:   call void @h(i32 [[CleanupReload]]
   call void @h(i32 %phi.cleanup)
   br label %merge
 
 right:
   ; CHECK: right:
   ; CHECK:   call void @h(i32 [[CleanupReload]]
   call void @h(i32 %phi.cleanup)
   br label %merge
 
 merge:
   ; need store for %phi.catch
   ; CHECK:      merge:
   ; CHECK-NEXT:   store i32 [[CleanupReload]], i32* [[CatchSlot:%[^ ]+]]
   ; CHECK-NEXT:   cleanupret
-  cleanupret %cp unwind label %catchpad
+  cleanupret from %cp unwind label %catchswitch
 
 invoke.cont2:
   ; need store for %phi.catch
   ; CHECK:      invoke.cont2:
   ; CHECK-NEXT:   store i32 3, i32* [[CatchSlot]]
   ; CHECK-NEXT:   invoke void @f
   invoke void @f()
-          to label %exit unwind label %catchpad
+          to label %exit unwind label %catchswitch
 
-catchpad:
-  ; CHECK: catchpad:
-  ; CHECK-NEXT: catchpad []
+catchswitch:
+  ; CHECK: catchswitch:
+  ; CHECK-NEXT: catchswitch within none
   %phi.catch = phi i32 [ %phi.cleanup, %merge ], [ 3, %invoke.cont2 ]
-  %cp2 = catchpad [] to label %catch unwind label %catchend
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:
   ; CHECK: catch:
+  ; CHECK:   catchpad within %cs1
   ; CHECK:   [[CatchReload:%[^ ]+]] = load i32, i32* [[CatchSlot]]
   ; CHECK:   call void @h(i32 [[CatchReload]]
+  %cp2 = catchpad within %cs1 []
   call void @h(i32 %phi.catch)
-  catchret %cp2 to label %exit
-
-catchend:
-  catchendpad unwind to caller
+  catchret from %cp2 to label %exit
 
 exit:
   ret void
 }
 
 ; We used to demote %x, but we don't need to anymore.
 ; CHECK-LABEL: @test6(
 define void @test6() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   ; CHECK: entry:
   ; CHECK: %x = invoke i32 @g()
   ; CHECK-NEXT: to label %loop unwind label %to_caller
   %x = invoke i32 @g()
           to label %loop unwind label %to_caller
 to_caller:
-  %cp1 = cleanuppad []
-  cleanupret %cp1 unwind to caller
+  %cp1 = cleanuppad within none []
+  cleanupret from %cp1 unwind to caller
 loop:
   invoke void @f()
           to label %loop unwind label %cleanup
 cleanup:
   ; CHECK: cleanup:
   ; CHECK:   call void @h(i32 %x)
-  %cp2 = cleanuppad []
+  %cp2 = cleanuppad within none []
   call void @h(i32 %x)
-  cleanupret %cp2 unwind to caller
+  cleanupret from %cp2 unwind to caller
 }
 
 ; CHECK-LABEL: @test7(
 define void @test7() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   ; %x is an EH pad phi, so gets stored in pred here
   ; CHECK: entry:
   ; CHECK:   store i32 1, i32* [[SlotX:%[^ ]+]]
   ; CHECK:   invoke void @f()
   invoke void @f()
      to label %invoke.cont unwind label %catchpad
 invoke.cont:
   ; %x is an EH pad phi, so gets stored in pred here
   ; CHECK: invoke.cont:
   ; CHECK:   store i32 2, i32* [[SlotX]]
   ; CHECK:   invoke void @f()
   invoke void @f()
     to label %exit unwind label %catchpad
 catchpad:
   ; %x phi should be eliminated
   ; CHECK: catchpad:
-  ; CHECK-NEXT: %[[CatchPad:[^ ]+]] = catchpad []
+  ; CHECK-NEXT: catchswitch within none
   %x = phi i32 [ 1, %entry ], [ 2, %invoke.cont ]
-  %cp = catchpad [] to label %catch unwind label %catchend
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 catch:
+  ; CHECK: catch:
+  ; CHECK-NEXT: %[[CatchPad:[^ ]+]] = catchpad within %cs1 []
+  %cp = catchpad within %cs1 []
   %b = call i1 @i()
   br i1 %b, label %left, label %right
 left:
   ; Edge from %left to %join needs to be split so that
   ; the load of %x can be inserted *after* the catchret
   ; CHECK: left:
-  ; CHECK-NEXT: catchret %[[CatchPad]] to label %[[SplitLeft:[^ ]+]]
-  catchret %cp to label %join
+  ; CHECK-NEXT: catchret from %[[CatchPad]] to label %[[SplitLeft:[^ ]+]]
+  catchret from %cp to label %join
   ; CHECK: [[SplitLeft]]:
   ; CHECK:   [[LoadX:%[^ ]+]] = load i32, i32* [[SlotX]]
   ; CHECK:   br label %join
 right:
   ; Edge from %right to %join needs to be split so that
   ; the load of %y can be inserted *after* the catchret
   ; CHECK: right:
   ; CHECK:   %y = call i32 @g()
-  ; CHECK:   catchret %[[CatchPad]] to label %join
+  ; CHECK:   catchret from %[[CatchPad]] to label %join
   %y = call i32 @g()
-  catchret %cp to label %join
-catchend:
-  catchendpad unwind to caller
+  catchret from %cp to label %join
 join:
   ; CHECK: join:
   ; CHECK:   %phi = phi i32 [ [[LoadX]], %[[SplitLeft]] ], [ %y, %right ]
   %phi = phi i32 [ %x, %left ], [ %y, %right ]
   call void @h(i32 %phi)
   br label %exit
 exit:
   ret void
 }
 
 ; CHECK-LABEL: @test8(
 define void @test8() personality i32 (...)* @__CxxFrameHandler3 { entry:
   invoke void @f()
           to label %done unwind label %cleanup1
   invoke void @f()
           to label %done unwind label %cleanup2
 
 done:
   ret void
 
 cleanup1:
-  ; CHECK: [[CleanupPad1:%[^ ]+]] = cleanuppad []
+  ; CHECK: [[CleanupPad1:%[^ ]+]] = cleanuppad within none []
   ; CHECK-NEXT: call void @f()
-  ; CHECK-NEXT: cleanupret [[CleanupPad1]]
-  %cp0 = cleanuppad []
+  ; CHECK-NEXT: cleanupret from [[CleanupPad1]]
+  %cp0 = cleanuppad within none []
   br label %cleanupexit
 
 cleanup2:
-  ; CHECK: cleanuppad []
+  ; CHECK: cleanuppad within none []
   ; CHECK-NEXT: call void @f()
   ; CHECK-NEXT: unreachable
-  %cp1 = cleanuppad []
+  %cp1 = cleanuppad within none []
   br label %cleanupexit
 
 cleanupexit:
   call void @f()
-  cleanupret %cp0 unwind label %cleanup2
+  cleanupret from %cp0 unwind label %cleanup2
 }

llvm/trunk/test/CodeGen/WinEH/wineh-exceptionpointer.ll

-; RUN: llc -mtriple=x86_64-pc-windows-coreclr < %s | FileCheck %s
-
-declare void @ProcessCLRException()
-declare i8 addrspace(1)* @llvm.eh.exceptionpointer.p1i8(token)
-declare void @f()
-declare void @g(i32 addrspace(1)*)
-
-; CHECK-LABEL: test1: # @test1
-define void @test1() personality i8* bitcast (void ()* @ProcessCLRException to i8*) {
-entry:
-  invoke void @f()
-    to label %exit unwind label %catch.pad
-catch.pad:
-; CHECK: {{^[^: ]+}}: # %catch.pad
-  %catch = catchpad [i32 5]
-    to label %catch.body unwind label %catch.end
-catch.body:
-  %exn = call i8 addrspace(1)* @llvm.eh.exceptionpointer.p1i8(token %catch)
-  %cast_exn = bitcast i8 addrspace(1)* %exn to i32 addrspace(1)*
-  ; CHECK: movq %rdx, %rcx
-  ; CHECK-NEXT: callq g
-  call void @g(i32 addrspace(1)* %cast_exn)
-  catchret %catch to label %exit
-catch.end:
-  catchendpad unwind to caller
-exit:
-  ret void
-}

llvm/trunk/test/CodeGen/WinEH/wineh-intrinsics.ll

 
 declare void @f(...)
 
 define void @test1() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   invoke void (...) @f(i32 1)
      to label %exit unwind label %catchpad
 catchpad:
-  %catch = catchpad [i32 1] to label %do_catch unwind label %catchend
+  %cs1 = catchswitch within none [label %do_catch] unwind to caller
 do_catch:
+  %catch = catchpad within %cs1 [i32 1]
   %exn = call i8* @llvm.eh.exceptionpointer.p0i8(token %catch)
   call void (...) @f(i8* %exn)
-  catchret %catch to label %exit
-catchend:
-  catchendpad unwind to caller
+  catchret from %catch to label %exit
 exit:
   ret void
 }
 
 define void @test2() personality i32 (...)* @ProcessManagedException {
 entry:
   invoke void (...) @f(i32 1)
      to label %exit unwind label %catchpad
 catchpad:
-  %catch = catchpad [i32 1] to label %do_catch unwind label %catchend
+  %cs1 = catchswitch within none [label %do_catch] unwind to caller
 do_catch:
+  %catch = catchpad within %cs1 [i32 1]
   %exn = call i8 addrspace(1)* @llvm.eh.exceptionpointer.p1i8(token %catch)
   call void (...) @f(i8 addrspace(1)* %exn)
-  catchret %catch to label %exit
-catchend:
-  catchendpad unwind to caller
+  catchret from %catch to label %exit
 exit:
   ret void
 }
 
 declare i32 @__CxxFrameHandler3(...)
 declare i32 @ProcessManagedException(...)

llvm/trunk/test/CodeGen/WinEH/wineh-multi-parent-cloning.ll

-; RUN: opt -mtriple=x86_x64-pc-windows-msvc -S -winehprepare  < %s | FileCheck %s
-
-declare i32 @__CxxFrameHandler3(...)
-
-declare void @f()
-declare i32 @g()
-declare void @h(i32)
-declare i1 @b()
-
-define void @test1() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %invoke.cont unwind label %left
-invoke.cont:
-  invoke void @f()
-    to label %exit unwind label %right
-left:
-  cleanuppad []
-  br label %shared
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  br label %shared
-right.end:
-  catchendpad unwind to caller
-shared:
-  %x = call i32 @g()
-  invoke void @f()
-    to label %shared.cont unwind label %inner
-shared.cont:
-  unreachable
-inner:
-  %i = cleanuppad []
-  call void @h(i32 %x)
-  cleanupret %i unwind label %right.end
-exit:
-  ret void
-}
-; %inner is a cleanup which appears both as a child of
-; %left and as a child of %right.  Since statically we
-; need each funclet to have a single parent, we need to
-; clone the entire %inner funclet so we can have one
-; copy under each parent.  The cleanupret in %inner
-; unwinds to the catchendpad for %right, so the copy
-; of %inner under %right should include it; the copy
-; of %inner under %left should instead have an
-; `unreachable` inserted there, but the copy under
-; %left still needs to be created because it's possible
-; the dynamic path enters %left, then enters %inner,
-; then calls @h, and that the call to @h doesn't return.
-; CHECK-LABEL: define void @test1(
-; CHECK:     left:
-; CHECK:       cleanuppad
-; CHECK:       %x.for.left = call i32 @g()
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     right:
-; CHECK:           to label %right.catch unwind label %right.end
-; CHECK:     right.catch:
-; CHECK:       %x = call i32 @g()
-; CHECK:           to label %shared.cont unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     right.end:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     shared.cont:
-; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       [[I_R:\%.+]] = cleanuppad []
-; CHECK:       call void @h(i32 %x)
-; CHECK:       cleanupret [[I_R]] unwind label %right.end
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       [[I_L:\%.+]] = cleanuppad []
-; CHECK:       call void @h(i32 %x.for.left)
-; CHECK:       unreachable
-
-
-define void @test2() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %invoke.cont unwind label %left
-invoke.cont:
-  invoke void @f()
-    to label %exit unwind label %right
-left:
-  cleanuppad []
-  br label %shared
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  br label %shared
-right.end:
-  catchendpad unwind to caller
-shared:
-  %x = call i32 @g()
-  invoke void @f()
-    to label %shared.cont unwind label %inner
-shared.cont:
-  unreachable
-inner:
-  catchpad []
-    to label %inner.catch unwind label %inner.end
-inner.catch:
-  call void @h(i32 %x)
-  unreachable
-inner.end:
-  catchendpad unwind label %right.end
-exit:
-  ret void
-}
-; In this case left and right are both parents of inner.  This differs from
-; @test1 in that inner is a catchpad rather than a cleanuppad, which makes
-; inner.end a block that gets cloned so that left and right each contain a
-; copy (catchendpad blocks are considered to be part of the parent funclet
-; of the associated catchpad). The catchendpad in %inner.end unwinds to
-; %right.end (which belongs to the entry funclet).
-; CHECK-LABEL: define void @test2(
-; CHECK:     left:
-; CHECK:       cleanuppad
-; CHECK:       %x.for.left = call i32 @g()
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     right:
-; CHECK:           to label %right.catch unwind label %[[RIGHT_END:.+]]
-; CHECK:     right.catch:
-; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     [[RIGHT_END]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[SHARED_CONT_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
-; CHECK:     [[INNER_CATCH_RIGHT]]:
-; CHECK:       call void @h(i32 %x)
-; CHECK:       unreachable
-; CHECK:     [[INNER_CATCH_LEFT]]:
-; CHECK:       call void @h(i32 %x.for.left)
-; CHECK:       unreachable
-; CHECK:     [[INNER_END_LEFT]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[INNER_END_RIGHT]]:
-; CHECK:       catchendpad unwind label %[[RIGHT_END]]
-
-define void @test3() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %exit unwind label %left
-left:
-  %l = cleanuppad []
-  br label %shared
-left.end:
-  cleanupendpad %l unwind label %right
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  br label %shared
-right.end:
-  catchendpad unwind to caller
-shared:
-  %x = call i32 @g()
-  invoke void @f()
-    to label %shared.cont unwind label %inner
-shared.cont:
-  unreachable
-inner:
-  catchpad []
-    to label %inner.catch unwind label %inner.end
-inner.catch:
-  call void @h(i32 %x)
-  unreachable
-inner.end:
-  catchendpad unwind label %left.end
-exit:
-  ret void
-}
-; In this case, %left and %right are siblings with %entry as the parent of both,
-; while %left and %right are both parents of %inner.  The catchendpad in
-; %inner.end unwinds to %left.end.  When %inner is cloned a copy of %inner.end
-; will be made for both %left and %right, but because %left.end is a cleanup pad
-; and %right is a catch pad the unwind edge from the copy of %inner.end for
-; %right must be removed.
-; CHECK-LABEL: define void @test3(
-; CHECK:     left:
-; CHECK:       %l = cleanuppad []
-; CHECK:       %x.for.left = call i32 @g()
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     [[LEFT_END:left.end.*]]:
-; CHECK:       cleanupendpad %l unwind label %right
-; CHECK:     right:
-; CHECK:           to label %right.catch unwind label %[[RIGHT_END:.+]]
-; CHECK:     right.catch:
-; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     [[RIGHT_END]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[SHARED_CONT_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
-; CHECK:     [[INNER_CATCH_RIGHT]]:
-; CHECK:       call void @h(i32 %x)
-; CHECK:       unreachable
-; CHECK:     [[INNER_CATCH_LEFT]]:
-; CHECK:       call void @h(i32 %x.for.left)
-; CHECK:       unreachable
-; CHECK:     [[INNER_END_LEFT]]:
-; CHECK:       catchendpad unwind label %[[LEFT_END]]
-; CHECK:     [[INNER_END_RIGHT]]:
-; CHECK:       catchendpad unwind to caller
-
-
-define void @test4() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %exit unwind label %left
-left:
-  catchpad []
-    to label %left.catch unwind label %left.end
-left.catch:
-  br label %shared
-left.end:
-  catchendpad unwind label %right
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  br label %shared
-right.end:
-  catchendpad unwind to caller
-shared:
-  %x = call i32 @g()
-  invoke void @f()
-    to label %shared.cont unwind label %inner
-shared.cont:
-  unreachable
-inner:
-  catchpad []
-    to label %inner.catch unwind label %inner.end
-inner.catch:
-  call void @h(i32 %x)
-  unreachable
-inner.end:
-  catchendpad unwind label %left.end
-exit:
-  ret void
-}
-; This is a variation of @test3 in which both %left and %right are catch pads.
-; In this case, %left and %right are siblings with %entry as the parent of both,
-; while %left and %right are both parents of %inner.  The catchendpad in
-; %inner.end unwinds to %left.end.  When %inner is cloned a copy of %inner.end
-; will be made for both %left and %right, but because the catchpad in %right
-; does not unwind to %left.end the unwind edge from the copy of %inner.end for
-; %right must be removed.
-; CHECK-LABEL: define void @test4(
-; CHECK:     left:
-; CHECK:       catchpad []
-; CHECK:           to label %left.catch unwind label %[[LEFT_END:.+]]
-; CHECK:     left.catch:
-; CHECK:       %x.for.left = call i32 @g()
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     [[LEFT_END]]:
-; CHECK:       catchendpad unwind label %right
-; CHECK:     right:
-; CHECK:           to label %right.catch unwind label %[[RIGHT_END:.+]]
-; CHECK:     right.catch:
-; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     [[RIGHT_END]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[SHARED_CONT_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
-; CHECK:     [[INNER_CATCH_RIGHT]]:
-; CHECK:       call void @h(i32 %x)
-; CHECK:       unreachable
-; CHECK:     [[INNER_CATCH_LEFT]]:
-; CHECK:       call void @h(i32 %x.for.left)
-; CHECK:       unreachable
-; CHECK:     [[INNER_END_RIGHT]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[INNER_END_LEFT]]:
-; CHECK:       catchendpad unwind label %[[LEFT_END]]
-
-
-define void @test5() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %exit unwind label %left
-left:
-  catchpad []
-    to label %left.catch unwind label %left.end
-left.catch:
-  br label %shared
-left.end:
-  catchendpad unwind label %right
-right:
-  %r = cleanuppad []
-  br label %shared
-shared:
-  %x = call i32 @g()
-  invoke void @f()
-    to label %shared.cont unwind label %inner
-shared.cont:
-  unreachable
-inner:
-  catchpad []
-    to label %inner.catch unwind label %inner.end
-inner.catch:
-  call void @h(i32 %x)
-  unreachable
-inner.end:
-  catchendpad unwind label %left.end
-exit:
-  ret void
-}
-; Like @test3, %left and %right are siblings with %entry as the parent of both,
-; while %left and %right are both parents of %inner.  This case makes %left a
-; catch and %right a cleanup so that %inner unwinds to %left.end, which is a
-; block in %entry.  The %inner funclet is cloned for %left and %right, but the
-; copy of %inner.end for %right must have its unwind edge removed because the
-; catchendpad at %left.end is not compatible with %right.
-; CHECK-LABEL: define void @test5(
-; CHECK:     left:
-; CHECK:       catchpad []
-; CHECK:           to label %left.catch unwind label %[[LEFT_END:.+]]
-; CHECK:     left.catch:
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     [[LEFT_END]]:
-; CHECK:       catchendpad unwind label %right
-; CHECK:     right:
-; CHECK:       %r = cleanuppad []
-; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     [[SHARED_CONT_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
-; CHECK:     [[INNER_CATCH_RIGHT]]:
-; CHECK:       call void @h(i32 %x)
-; CHECK:       unreachable
-; CHECK:     [[INNER_CATCH_LEFT]]:
-; CHECK:       call void @h(i32 %x.for.left)
-; CHECK:       unreachable
-; CHECK:     [[INNER_END_RIGHT]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[INNER_END_LEFT]]:
-; CHECK:       catchendpad unwind label %[[LEFT_END]]
-
-define void @test6() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %exit unwind label %left
-left:
-  catchpad []
-    to label %left.catch unwind label %left.end
-left.catch:
-  br label %shared
-left.end:
-  catchendpad unwind label %middle
-middle:
-  %m = catchpad []
-    to label %middle.catch unwind label %middle.end
-middle.catch:
-  catchret %m to label %exit
-middle.end:
-  catchendpad unwind label %right
-right:
-  %r = cleanuppad []
-  br label %shared
-shared:
-  %x = call i32 @g()
-  invoke void @f()
-    to label %shared.cont unwind label %inner
-shared.cont:
-  unreachable
-inner:
-  catchpad []
-    to label %inner.catch unwind label %inner.end
-inner.catch:
-  call void @h(i32 %x)
-  unreachable
-inner.end:
-  catchendpad unwind label %left.end
-exit:
-  ret void
-}
-; This is like @test5 but it inserts another sibling between %left and %right.
-; In this case %left, %middle and %right are all siblings, while %left and
-; %right are both parents of %inner.  This checks the proper handling of the
-; catchendpad in %inner.end (which will be cloned so that %left and %right both
-; have copies) unwinding to a catchendpad that unwinds to a sibling.
-; CHECK-LABEL: define void @test6(
-; CHECK:     left:
-; CHECK:       catchpad []
-; CHECK:           to label %left.catch unwind label %[[LEFT_END:.+]]
-; CHECK:     left.catch:
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     [[LEFT_END]]:
-; CHECK:       catchendpad unwind label %middle
-; CHECK:     middle:
-; CHECK:       catchpad []
-; CHECK:         to label %middle.catch unwind label %middle.end
-; CHECK:     middle.catch:
-; CHECK:       catchret %m to label %exit
-; CHECK:     middle.end:
-; CHECK:       catchendpad unwind label %right
-; CHECK:     right:
-; CHECK:       %r = cleanuppad []
-; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     [[SHARED_CONT_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
-; CHECK:     [[INNER_CATCH_RIGHT]]:
-; CHECK:       call void @h(i32 %x)
-; CHECK:       unreachable
-; CHECK:     [[INNER_CATCH_LEFT]]:
-; CHECK:       call void @h(i32 %x.for.left)
-; CHECK:       unreachable
-; CHECK:     [[INNER_END_RIGHT]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[INNER_END_LEFT]]:
-; CHECK:       catchendpad unwind label %[[LEFT_END]]
-
-
-define void @test7() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %exit unwind label %left
-left:
-  catchpad []
-    to label %left.catch unwind label %left.end
-left.catch:
-  br label %shared
-left.end:
-  catchendpad unwind label %right
-right:
-  %r = cleanuppad []
-  br label %shared
-shared:
-  %x = call i32 @g()
-  invoke void @f()
-    to label %shared.cont unwind label %inner
-shared.cont:
-  unreachable
-inner:
-  catchpad []
-    to label %inner.catch unwind label %inner.end
-inner.catch:
-  call void @h(i32 %x)
-  unreachable
-inner.end:
-  catchendpad unwind label %inner.sibling
-inner.sibling:
-  %is = cleanuppad []
-  call void @h(i32 0)
-  cleanupret %is unwind label %left.end
-exit:
-  ret void
-}
-; This is like @test5 but instead of unwinding to %left.end, the catchendpad
-; in %inner.end unwinds to a sibling cleanup pad. Both %inner (along with its
-; associated blocks) and %inner.sibling must be cloned for %left and %right.
-; The clones of %inner will be identical, but the copy of %inner.sibling for
-; %right must end with an unreachable instruction, because it cannot unwind to
-; %left.end.
-; CHECK-LABEL: define void @test7(
-; CHECK:     left:
-; CHECK:       catchpad []
-; CHECK:           to label %left.catch unwind label %[[LEFT_END:.+]]
-; CHECK:     left.catch:
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     [[LEFT_END]]:
-; CHECK:       catchendpad unwind label %[[RIGHT:.+]]
-; CHECK:     [[RIGHT]]:
-; CHECK:       [[R:\%.+]] = cleanuppad []
-; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     [[SHARED_CONT_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
-; CHECK:     [[INNER_CATCH_RIGHT]]:
-; CHECK:       call void @h(i32 %x)
-; CHECK:       unreachable
-; CHECK:     [[INNER_CATCH_LEFT]]:
-; CHECK:       call void @h(i32 %x.for.left)
-; CHECK:       unreachable
-; CHECK:     [[INNER_END_RIGHT]]:
-; CHECK:       catchendpad unwind label %[[INNER_SIBLING_RIGHT:.+]]
-; CHECK:     [[INNER_END_LEFT]]:
-; CHECK:       catchendpad unwind label %[[INNER_SIBLING_LEFT:.+]]
-; CHECK:     [[INNER_SIBLING_RIGHT]]
-; CHECK:       [[IS_R:\%.+]] = cleanuppad []
-; CHECK:       call void @h(i32 0)
-; CHECK:       unreachable
-; CHECK:     [[INNER_SIBLING_LEFT]]
-; CHECK:       [[IS_L:\%.+]] = cleanuppad []
-; CHECK:       call void @h(i32 0)
-; CHECK:       cleanupret [[IS_L]] unwind label %[[LEFT_END]]
-
-
-define void @test8() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %invoke.cont unwind label %left
-invoke.cont:
-  invoke void @f()
-    to label %unreachable unwind label %right
-left:
-  cleanuppad []
-  invoke void @f() to label %unreachable unwind label %inner
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  invoke void @f() to label %unreachable unwind label %inner
-right.end:
-  catchendpad unwind to caller
-inner:
-  %i = cleanuppad []
-  %x = call i32 @g()
-  call void @h(i32 %x)
-  cleanupret %i unwind label %right.end
-unreachable:
-  unreachable
-}
-; Another case of a two-parent child (like @test1), this time
-; with the join at the entry itself instead of following a
-; non-pad join.
-; CHECK-LABEL: define void @test8(
-; CHECK:     invoke.cont:
-; CHECK:           to label %[[UNREACHABLE_ENTRY:.+]] unwind label %right
-; CHECK:     left:
-; CHECK:           to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     right:
-; CHECK:           to label %right.catch unwind label %right.end
-; CHECK:     right.catch:
-; CHECK:           to label %unreachable unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     right.end:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       [[I_R:\%.+]] = cleanuppad []
-; CHECK:       [[X_R:\%.+]] = call i32 @g()
-; CHECK:       call void @h(i32 [[X_R]])
-; CHECK:       cleanupret [[I_R]] unwind label %right.end
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       [[I_L:\%.+]] = cleanuppad []
-; CHECK:       [[X_L:\%.+]] = call i32 @g()
-; CHECK:       call void @h(i32 [[X_L]])
-; CHECK:       unreachable
-; CHECK:     unreachable:
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_ENTRY]]:
-; CHECK:       unreachable
-
-
-define void @test9() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %invoke.cont unwind label %left
-invoke.cont:
-  invoke void @f()
-    to label %unreachable unwind label %right
-left:
-  cleanuppad []
-  br label %shared
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  br label %shared
-right.end:
-  catchendpad unwind to caller
-shared:
-  invoke void @f()
-    to label %unreachable unwind label %inner
-inner:
-  cleanuppad []
-  invoke void @f()
-    to label %unreachable unwind label %inner.child
-inner.child:
-  cleanuppad []
-  %x = call i32 @g()
-  call void @h(i32 %x)
-  unreachable
-unreachable:
-  unreachable
-}
-; %inner is a two-parent child which itself has a child; need
-; to make two copies of both the %inner and %inner.child.
-; CHECK-LABEL: define void @test9(
-; CHECK:     invoke.cont:
-; CHECK:               to label %[[UNREACHABLE_ENTRY:.+]] unwind label %right
-; CHECK:     left:
-; CHECK:               to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     right:
-; CHECK:               to label %right.catch unwind label %right.end
-; CHECK:     right.catch:
-; CHECK:               to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     right.end:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:               to label %[[UNREACHABLE_INNER_RIGHT:.+]] unwind label %[[INNER_CHILD_RIGHT:.+]]
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:               to label %[[UNREACHABLE_INNER_LEFT:.+]] unwind label %[[INNER_CHILD_LEFT:.+]]
-; CHECK:     [[INNER_CHILD_RIGHT]]:
-; CHECK:       [[TMP:\%.+]] = cleanuppad []
-; CHECK:       [[X:\%.+]] = call i32 @g()
-; CHECK:       call void @h(i32 [[X]])
-; CHECK:       unreachable
-; CHECK:     [[INNER_CHILD_LEFT]]:
-; CHECK:       [[TMP:\%.+]] = cleanuppad []
-; CHECK:       [[X:\%.+]] = call i32 @g()
-; CHECK:       call void @h(i32 [[X]])
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_INNER_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_INNER_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_ENTRY]]:
-; CHECK:       unreachable
-
-
-define void @test10() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %invoke.cont unwind label %left
-invoke.cont:
-  invoke void @f()
-    to label %unreachable unwind label %right
-left:
-  cleanuppad []
-  call void @h(i32 1)
-  invoke void @f()
-    to label %unreachable unwind label %right
-right:
-  cleanuppad []
-  call void @h(i32 2)
-  invoke void @f()
-    to label %unreachable unwind label %left
-unreachable:
-  unreachable
-}
-; This is an irreducible loop with two funclets that enter each other;
-; need to make two copies of each funclet (one a child of root, the
-; other a child of the opposite funclet), but also make sure not to
-; clone self-descendants (if we tried to do that we'd need to make an
-; infinite number of them).  Presumably if optimizations ever generated
-; such a thing it would mean that one of the two cleanups was originally
-; the parent of the other, but that we'd somehow lost track in the CFG
-; of which was which along the way; generating each possibility lets
-; whichever case was correct execute correctly.
-; CHECK-LABEL: define void @test10(
-; CHECK:     entry:
-; CHECK:               to label %invoke.cont unwind label %[[LEFT:.+]]
-; CHECK:     invoke.cont:
-; CHECK:               to label %[[UNREACHABLE_ENTRY:.+]] unwind label %[[RIGHT:.+]]
-; CHECK:     [[LEFT_FROM_RIGHT:.+]]:
-; CHECK:       call void @h(i32 1)
-; CHECK:       call void @f()
-; CHECK:       unreachable
-; CHECK:     [[LEFT]]:
-; CHECK:       call void @h(i32 1)
-; CHECK:       invoke void @f()
-; CHECK:               to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[RIGHT_FROM_LEFT:.+]]
-; CHECK:     [[RIGHT]]:
-; CHECK:       call void @h(i32 2)
-; CHECK:       invoke void @f()
-; CHECK:               to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[LEFT_FROM_RIGHT]]
-; CHECK:     [[RIGHT_FROM_LEFT]]:
-; CHECK:       call void @h(i32 2)
-; CHECK:       call void @f()
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[UNREACHABLE_ENTRY]]:
-; CHECK:       unreachable
-
-
-define void @test11() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %exit unwind label %left
-left:
-  catchpad []
-    to label %left.catch unwind label %left.sibling
-left.catch:
-  br label %shared
-left.sibling:
-  %ls = catchpad []
-    to label %left.sibling.catch unwind label %left.end
-left.sibling.catch:
-  catchret %ls to label %exit
-left.end:
-  catchendpad unwind label %right
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  br label %shared
-right.end:
-  catchendpad unwind to caller
-shared:
-  %x = call i32 @g()
-  invoke void @f()
-    to label %shared.cont unwind label %inner
-shared.cont:
-  unreachable
-inner:
-  catchpad []
-    to label %inner.catch unwind label %inner.end
-inner.catch:
-  call void @h(i32 %x)
-  unreachable
-inner.end:
-  catchendpad unwind label %left.end
-exit:
-  ret void
-}
-; This is a variation of @test4 in which the shared child funclet unwinds to a
-; catchend pad that is the unwind destination of %left.sibling rather than %left
-; but is still a valid destination for %inner as reach from %left.
-; When %inner is cloned a copy of %inner.end will be made for both %left and
-; %right, but because the catchpad in %right does not unwind to %left.end the
-; unwind edge from the copy of %inner.end for %right must be removed.
-; CHECK-LABEL: define void @test11(
-; CHECK:     left:
-; CHECK:       catchpad []
-; CHECK:           to label %left.catch unwind label %left.sibling
-; CHECK:     left.catch:
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     left.sibling:
-; CHECK:       catchpad []
-; CHECK:           to label %left.sibling.catch unwind label %[[LEFT_END:.+]]
-; CHECK:     [[LEFT_END]]:
-; CHECK:       catchendpad unwind label %right
-; CHECK:     right:
-; CHECK:           to label %right.catch unwind label %[[RIGHT_END:.+]]
-; CHECK:     right.catch:
-; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     [[RIGHT_END]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[SHARED_CONT_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
-; CHECK:     [[INNER_CATCH_RIGHT]]:
-; CHECK:       call void @h(i32 %x)
-; CHECK:       unreachable
-; CHECK:     [[INNER_CATCH_LEFT]]:
-; CHECK:       call void @h(i32 %x.for.left)
-; CHECK:       unreachable
-; CHECK:     [[INNER_END_RIGHT]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[INNER_END_LEFT]]:
-; CHECK:       catchendpad unwind label %[[LEFT_END]]
-
-
-define void @test12() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %exit unwind label %left
-left:
-  catchpad []
-    to label %left.catch unwind label %right
-left.catch:
-  br label %shared
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  br label %shared
-right.end:
-  catchendpad unwind to caller
-shared:
-  %x = call i32 @g()
-  invoke void @f()
-    to label %shared.cont unwind label %inner
-shared.cont:
-  unreachable
-inner:
-  catchpad []
-    to label %inner.catch unwind label %inner.end
-inner.catch:
-  call void @h(i32 %x)
-  unreachable
-inner.end:
-  catchendpad unwind label %right.end
-exit:
-  ret void
-}
-; In this case %left and %right are both parents of %inner, so %inner must be
-; cloned but the catchendpad unwind target in %inner.end is valid for both
-; parents, so the unwind edge should not be removed in either case.
-; CHECK-LABEL: define void @test12(
-; CHECK:     left:
-; CHECK:       catchpad []
-; CHECK:           to label %left.catch unwind label %right
-; CHECK:     left.catch:
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     right:
-; CHECK:           to label %right.catch unwind label %[[RIGHT_END:.+]]
-; CHECK:     right.catch:
-; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     [[RIGHT_END]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[SHARED_CONT_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
-; CHECK:     [[INNER_CATCH_RIGHT]]:
-; CHECK:       call void @h(i32 %x)
-; CHECK:       unreachable
-; CHECK:     [[INNER_CATCH_LEFT]]:
-; CHECK:       call void @h(i32 %x.for.left)
-; CHECK:       unreachable
-; CHECK:     [[INNER_END_RIGHT]]:
-; CHECK:       catchendpad unwind label %[[RIGHT_END]]
-; CHECK:     [[INNER_END_LEFT]]:
-; CHECK:       catchendpad unwind label %[[RIGHT_END]]
-
-define void @test13() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %invoke.cont unwind label %left
-invoke.cont:
-  invoke void @f()
-    to label %exit unwind label %right
-left:
-  %l = catchpad []
-    to label %left.cont unwind label %left.end
-left.cont:
-  invoke void @f()
-    to label %left.ret unwind label %inner
-left.ret:
-  catchret %l to label %invoke.cont
-left.end:
-  catchendpad unwind to caller
-right:
-  %r = catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  invoke void @f()
-    to label %right.ret unwind label %inner
-right.ret:
-  catchret %r to label %exit
-right.end:
-  catchendpad unwind to caller
-shared:
-  call void @h(i32 0)
-  unreachable
-inner:
-  %i = catchpad []
-    to label %inner.catch unwind label %inner.end
-inner.catch:
-  call void @h(i32 1)
-  catchret %i to label %shared
-inner.end:
-  catchendpad unwind label %left.end
-exit:
-  ret void
-}
-; This case tests the scenario where a funclet with multiple parents uses a
-; catchret to return to a block that may exist in either parent funclets.
-; Both %left and %right are parents of %inner.  During common block cloning
-; a clone of %shared will be made so that both %left and %right have a copy,
-; but the copy of %shared for one of the parent funclets will be unreachable
-; until the %inner funclet is cloned.  When the %inner.catch block is cloned
-; during the %inner funclet cloning, the catchret instruction should be updated
-; so that the catchret in the copy %inner.catch for %left returns to the copy of
-; %shared in %left and the catchret in the copy of %inner.catch for %right
-; returns to the copy of %shared for %right.
-; CHECK-LABEL: define void @test13(
-; CHECK:     left:
-; CHECK:       %l = catchpad []
-; CHECK:           to label %left.cont unwind label %left.end
-; CHECK:     left.cont:
-; CHECK:       invoke void @f()
-; CHECK:           to label %left.ret unwind label %[[INNER_LEFT:.+]]
-; CHECK:     left.ret:
-; CHECK:       catchret %l to label %invoke.cont
-; CHECK:     left.end:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     right:
-; CHECK:       %r = catchpad []
-; CHECK:           to label %right.catch unwind label %right.end
-; CHECK:     right.catch:
-; CHECK:       invoke void @f()
-; CHECK:           to label %right.ret unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     right.ret:
-; CHECK:       catchret %r to label %exit
-; CHECK:     right.end:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[SHARED_RIGHT:.+]]:
-; CHECK:       call void @h(i32 0)
-; CHECK:       unreachable
-; CHECK:     [[SHARED_LEFT:.+]]:
-; CHECK:       call void @h(i32 0)
-; CHECK:       unreachable
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       %[[I_RIGHT:.+]] = catchpad []
-; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       %[[I_LEFT:.+]] = catchpad []
-; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
-; CHECK:     [[INNER_CATCH_RIGHT]]:
-; CHECK:       call void @h(i32 1)
-; CHECK:       catchret %[[I_RIGHT]] to label %[[SHARED_RIGHT]]
-; CHECK:     [[INNER_CATCH_LEFT]]:
-; CHECK:       call void @h(i32 1)
-; CHECK:       catchret %[[I_LEFT]] to label %[[SHARED_LEFT]]
-; CHECK:     [[INNER_END_LEFT]]:
-; CHECK:       catchendpad unwind label %[[LEFT_END]]
-; CHECK:     [[INNER_END_RIGHT]]:
-; CHECK:       catchendpad unwind to caller
-
-
-define void @test14() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %exit unwind label %left
-left:
-  %l = catchpad []
-    to label %shared unwind label %left.end
-left.cont:
-  invoke void @f()
-    to label %left.ret unwind label %right
-left.ret: 
-  catchret %l to label %exit
-left.end:
-  catchendpad unwind to caller
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  br label %shared
-right.end:
-  catchendpad unwind label %left.end
-shared:
-  invoke void @f()
-    to label %shared.cont unwind label %inner
-shared.cont:
-  unreachable
-inner:
-  %i = catchpad []
-    to label %inner.catch unwind label %inner.end
-inner.catch:
-  call void @h(i32 0)
-  catchret %i to label %left.cont
-inner.end:
-  catchendpad unwind label %left.end
-exit:
-  ret void
-}
-; This case tests another scenario where a funclet with multiple parents uses a
-; catchret to return to a block in one of the parent funclets.  Here %right and
-; %left are both parents of %inner and %left is a parent of %right.  The
-; catchret in %inner.catch will cause %left.cont and %left.ret to be cloned for
-; both %left and %right, but the catchret in %left.ret is invalid for %right
-; but the catchret instruction in the copy of %left.ret for %right will be
-; removed as an implausible terminator.
-; CHECK-LABEL: define void @test14(
-; CHECK:     left:
-; CHECK:       %l = catchpad []
-; CHECK:           to label %[[SHARED_LEFT:.+]] unwind label %[[LEFT_END:.+]]
-; CHECK:     [[LEFT_CONT:left.cont.*]]:
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[LEFT_RET:.+]] unwind label %[[RIGHT:.+]]
-; CHECK:     [[LEFT_RET]]:
-; CHECK:       catchret %l to label %exit
-; CHECK:     [[LEFT_END]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[RIGHT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[RIGHT_CATCH:.+]] unwind label %[[RIGHT_END:.+]]
-; CHECK:     [[RIGHT_CATCH]]:
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     [[RIGHT_END]]:
-; CHECK:       catchendpad unwind label %[[LEFT_END]]
-; CHECK:     [[SHARED_LEFT]]:
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     [[SHARED_CONT_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       [[I_LEFT:\%.+]] = catchpad []
-; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       [[I_RIGHT:\%.+]] = catchpad []
-; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
-; CHECK:     [[INNER_CATCH_LEFT]]:
-; CHECK:       call void @h(i32 0)
-; CHECK:       catchret [[I_LEFT]] to label %[[LEFT_CONT]]
-; CHECK:     [[INNER_CATCH_RIGHT]]:
-; CHECK:       call void @h(i32 0)
-; CHECK:       unreachable
-; CHECK:     [[INNER_END_LEFT]]:
-; CHECK:       catchendpad unwind label %[[LEFT_END]]
-; CHECK:     [[INNER_END_RIGHT]]:
-; CHECK:       catchendpad unwind to caller
-
-define void @test15() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %exit unwind label %left
-left:
-  %l = catchpad []
-    to label %left.catch unwind label %left.end
-left.catch:
-  invoke void @f()
-    to label %shared unwind label %right
-left.ret:
-  catchret %l to label %exit
-left.end:
-  catchendpad unwind to caller
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  br label %shared
-right.end:
-  catchendpad unwind label %left.end
-shared:
-  invoke void @f()
-    to label %shared.cont unwind label %inner
-shared.cont:
-  unreachable
-inner:
-  %i = catchpad []
-    to label %inner.catch unwind label %inner.end
-inner.catch:
-  call void @h(i32 0)
-  catchret %i to label %left.ret
-inner.end:
-  catchendpad unwind label %left.end
-exit:
-  ret void
-}
-; This case is a variation of test14 but instead of returning to an invoke the
-; catchret in %inner.catch returns to a catchret instruction.
-; CHECK-LABEL: define void @test15(
-; CHECK:     left:
-; CHECK:       %l = catchpad []
-; CHECK:           to label %left.catch unwind label %[[LEFT_END:.+]]
-; CHECK:     left.catch:
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_LEFT:.+]] unwind label %[[RIGHT:.+]]
-; CHECK:     [[LEFT_RET_RIGHT:.+]]:
-; CHECK:       unreachable
-; CHECK:     [[LEFT_RET_LEFT:.+]]:
-; CHECK:       catchret %l to label %exit
-; CHECK:     [[LEFT_END]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[RIGHT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[RIGHT_CATCH:.+]] unwind label %[[RIGHT_END:.+]]
-; CHECK:     [[RIGHT_CATCH]]:
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     [[RIGHT_END]]:
-; CHECK:       catchendpad unwind label %[[LEFT_END]]
-; CHECK:     [[SHARED_LEFT]]:
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     [[SHARED_CONT_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       [[I_LEFT:\%.+]] = catchpad []
-; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       [[I_RIGHT:\%.+]] = catchpad []
-; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
-; CHECK:     [[INNER_CATCH_LEFT]]:
-; CHECK:       call void @h(i32 0)
-; CHECK:       catchret [[I_LEFT]] to label %[[LEFT_RET_LEFT]]
-; CHECK:     [[INNER_CATCH_RIGHT]]:
-; CHECK:       call void @h(i32 0)
-; CHECK:       catchret [[I_RIGHT]] to label %[[LEFT_RET_RIGHT]]
-; CHECK:     [[INNER_END_RIGHT]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[INNER_END_LEFT]]:
-; CHECK:       catchendpad unwind label %[[LEFT_END]]
-
-
-define void @test16() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %exit unwind label %left
-left:
-  %l = cleanuppad []
-  br label %shared
-left.cont:
-  cleanupret %l unwind label %right
-left.end:
-  cleanupendpad %l unwind label %right
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  br label %shared
-right.end:
-  catchendpad unwind to caller
-shared:
-  invoke void @f()
-    to label %shared.cont unwind label %inner
-shared.cont:
-  unreachable
-inner:
-  %i = catchpad []
-    to label %inner.catch unwind label %inner.end
-inner.catch:
-  call void @h(i32 0)
-  catchret %i to label %left.cont
-inner.end:
-  catchendpad unwind label %left.end
-exit:
-  ret void
-}
-; This case is another variation of test14 but here the catchret in %inner.catch
-; returns to a cleanupret instruction.
-; CHECK-LABEL: define void @test16(
-; CHECK:     left:
-; CHECK:       %l = cleanuppad []
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     [[LEFT_CONT_RIGHT:.+]]:
-; CHECK:       unreachable
-; CHECK:     [[LEFT_CONT_LEFT:.+]]:
-; CHECK:       cleanupret %l unwind label %[[RIGHT:.+]]
-; CHECK:     [[LEFT_END_LEFT:.+]]:
-; CHECK:       cleanupendpad %l unwind label %[[RIGHT]]
-; CHECK:     [[RIGHT]]:
-; CHECK:       catchpad []
-; CHECK:           to label %[[RIGHT_CATCH:.+]] unwind label %[[RIGHT_END:.+]]
-; CHECK:     [[RIGHT_CATCH]]:
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     [[RIGHT_END]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[SHARED_CONT_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       [[I_RIGHT:\%.+]] = catchpad []
-; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       [[I_LEFT:\%.+]] = catchpad []
-; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
-; CHECK:     [[INNER_CATCH_RIGHT]]:
-; CHECK:       call void @h(i32 0)
-; CHECK:       catchret [[I_RIGHT]] to label %[[LEFT_CONT_RIGHT]]
-; CHECK:     [[INNER_CATCH_LEFT]]:
-; CHECK:       call void @h(i32 0)
-; CHECK:       catchret [[I_LEFT]] to label %[[LEFT_CONT_LEFT]]
-; CHECK:     [[INNER_END_LEFT]]:
-; CHECK:       catchendpad unwind label %[[LEFT_END_LEFT]]
-; CHECK:     [[INNER_END_RIGHT]]:
-; CHECK:       catchendpad unwind to caller
-
-
-define void @test17() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %invoke.cont unwind label %left
-invoke.cont:
-  invoke void @f()
-    to label %exit unwind label %right
-left:
-  %l = cleanuppad []
-  br label %shared
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  br label %shared
-right.end:
-  catchendpad unwind to caller
-shared:
-  invoke void @f()
-    to label %unreachable unwind label %inner
-unreachable:
-  unreachable
-inner:
-  %i = catchpad []
-    to label %inner.catch unwind label %inner.sibling
-inner.catch:
-  call void @h(i32 0)
-  unreachable
-inner.sibling:
-  %is = catchpad []
-    to label %inner.sibling.catch unwind label %inner.end
-inner.sibling.catch:
-  invoke void @f()
-    to label %unreachable unwind label %inner.end
-inner.end:
-  catchendpad unwind label %right.end
-exit:
-  ret void
-}
-; This case tests the scenario where two catchpads with the same catchendpad
-; have multiple parents.  Both %left and %right are parents of %inner and
-; %inner.sibling so both of the inner funclets must be cloned.  Because
-; the catchendpad in %inner.end unwinds to the catchendpad for %right, the
-; unwind edge should be removed for the copy of %inner.end that is reached
-; from %left.  In addition, the %inner.siblin.catch block contains an invoke
-; that unwinds to the shared inner catchendpad.  The unwind destination for
-; this invoke should be updated to unwind to the correct cloned %inner.end
-; for each path to the funclet.
-; CHECK-LABEL: define void @test17(
-; CHECK:     left:
-; CHECK:       %l = cleanuppad []
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     right:
-; CHECK:       catchpad []
-; CHECK:           to label %[[RIGHT_CATCH:.+]] unwind label %[[RIGHT_END:.+]]
-; CHECK:     [[RIGHT_CATCH]]:
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     [[RIGHT_END]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[SHARED_CONT_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       [[I_RIGHT:\%.+]] = catchpad []
-; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_SIBLING_RIGHT:.+]]
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       [[I_LEFT:\%.+]] = catchpad []
-; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_SIBLING_LEFT:.+]]
-; CHECK:     [[INNER_CATCH_RIGHT]]:
-; CHECK:       call void @h(i32 0)
-; CHECK:       unreachable
-; CHECK:     [[INNER_CATCH_LEFT]]:
-; CHECK:       call void @h(i32 0)
-; CHECK:       unreachable
-; CHECK:     [[INNER_SIBLING_RIGHT]]:
-; CHECK:       [[IS_RIGHT:\%.+]] = catchpad []
-; CHECK:           to label %[[INNER_SIBLING_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
-; CHECK:     [[INNER_SIBLING_LEFT]]:
-; CHECK:       [[IS_LEFT:\%.+]] = catchpad []
-; CHECK:           to label %[[INNER_SIBLING_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
-; CHECK:     [[INNER_SIBLING_CATCH_RIGHT]]:
-; CHECK:       invoke void @f()
-; CHECK:         to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[INNER_END_RIGHT]]
-; CHECK:     [[INNER_SIBLING_CATCH_LEFT]]:
-; CHECK:       invoke void @f()
-; CHECK:         to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[INNER_END_LEFT]]
-; CHECK:     [[INNER_END_LEFT]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[INNER_END_RIGHT]]:
-; CHECK:       catchendpad unwind label %[[RIGHT_END]]
-
-
-define void @test18() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %invoke.cont unwind label %left
-invoke.cont:
-  invoke void @f()
-    to label %exit unwind label %right
-left:
-  %l = cleanuppad []
-  br label %shared
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  br label %shared
-right.end:
-  catchendpad unwind to caller
-shared:
-  invoke void @f()
-    to label %unreachable unwind label %inner
-unreachable:
-  unreachable
-inner:
-  %i = catchpad []
-    to label %inner.catch unwind label %inner.sibling
-inner.catch:
-  invoke void @f()
-    to label %unreachable unwind label %inner.end
-inner.sibling:
-  %is = catchpad []
-    to label %inner.sibling.catch unwind label %inner.end
-inner.sibling.catch:
-  call void @h(i32 0)
-  unreachable
-inner.end:
-  catchendpad unwind label %right.end
-exit:
-  ret void
-}
-; This is like test17 except that the inner invoke is moved from the
-; %inner.sibling funclet to %inner so that it is unwinding to a
-; catchendpad block that has not yet been cloned.  The unwind destination
-; of the invoke should still be updated to reach the correct copy of
-; %inner.end for the path by which it is reached.
-; CHECK-LABEL: define void @test18(
-; CHECK:     left:
-; CHECK:       %l = cleanuppad []
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     right:
-; CHECK:       catchpad []
-; CHECK:           to label %[[RIGHT_CATCH:.+]] unwind label %[[RIGHT_END:.+]]
-; CHECK:     [[RIGHT_CATCH]]:
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     [[RIGHT_END]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[SHARED_CONT_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       [[I_RIGHT:\%.+]] = catchpad []
-; CHECK:           to label %[[INNER_CATCH_RIGHT:.+]] unwind label %[[INNER_SIBLING_RIGHT:.+]]
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       [[I_LEFT:\%.+]] = catchpad []
-; CHECK:           to label %[[INNER_CATCH_LEFT:.+]] unwind label %[[INNER_SIBLING_LEFT:.+]]
-; CHECK:     [[INNER_CATCH_RIGHT]]:
-; CHECK:       invoke void @f()
-; CHECK:         to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
-; CHECK:     [[INNER_CATCH_LEFT]]:
-; CHECK:       invoke void @f()
-; CHECK:         to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
-; CHECK:     [[INNER_SIBLING_RIGHT]]:
-; CHECK:       [[IS_RIGHT:\%.+]] = catchpad []
-; CHECK:           to label %[[INNER_SIBLING_CATCH_RIGHT:.+]] unwind label %[[INNER_END_RIGHT]]
-; CHECK:     [[INNER_SIBLING_LEFT]]:
-; CHECK:       [[IS_LEFT:\%.+]] = catchpad []
-; CHECK:           to label %[[INNER_SIBLING_CATCH_LEFT:.+]] unwind label %[[INNER_END_LEFT]]
-; CHECK:     [[INNER_SIBLING_CATCH_RIGHT]]:
-; CHECK:       call void @h(i32 0)
-; CHECK:       unreachable
-; CHECK:     [[INNER_SIBLING_CATCH_LEFT]]:
-; CHECK:       call void @h(i32 0)
-; CHECK:       unreachable
-; CHECK:     [[INNER_END_LEFT]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[INNER_END_RIGHT]]:
-; CHECK:       catchendpad unwind label %[[RIGHT_END]]
-
-
-define void @test19() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %invoke.cont unwind label %left
-invoke.cont:
-  invoke void @f()
-    to label %exit unwind label %right
-left:
-  %l = cleanuppad []
-  br label %shared
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  br label %shared
-right.end:
-  catchendpad unwind to caller
-shared:
-  invoke void @f()
-    to label %unreachable unwind label %inner
-unreachable:
-  unreachable
-inner:
-  %i = cleanuppad []
-  invoke void @f()
-    to label %unreachable unwind label %inner.end
-inner.end:
-  cleanupendpad %i unwind label %right.end
-exit:
-  ret void
-}
-; This case tests the scenario where an invoke in a funclet with multiple
-; parents unwinds to a cleanup end pad for the funclet.  The unwind destination
-; for the invoke should map to the correct copy of the cleanup end pad block.
-; CHECK-LABEL: define void @test19(
-; CHECK:     left:
-; CHECK:       %l = cleanuppad []
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     right:
-; CHECK:       catchpad []
-; CHECK:           to label %[[RIGHT_CATCH:.+]] unwind label %[[RIGHT_END:.+]]
-; CHECK:     [[RIGHT_CATCH]]:
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     [[RIGHT_END]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[SHARED_CONT_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       [[I_RIGHT:\%.+]] = cleanuppad []
-; CHECK:       invoke void @f()
-; CHECK:         to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[INNER_END_RIGHT:.+]]
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       [[I_LEFT:\%.+]] = cleanuppad []
-; CHECK:       invoke void @f()
-; CHECK:         to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[INNER_END_LEFT:.+]]
-; CHECK:     [[INNER_END_RIGHT]]:
-; CHECK:       cleanupendpad [[I_RIGHT]] unwind label %[[RIGHT_END]]
-; CHECK:     [[INNER_END_LEFT]]:
-; CHECK:       cleanupendpad [[I_LEFT]] unwind to caller
-
-define void @test20() personality i32 (...)* @__CxxFrameHandler3 {
-entry:
-  invoke void @f()
-    to label %invoke.cont unwind label %left
-invoke.cont:
-  invoke void @f()
-    to label %exit unwind label %right
-left:
-  %l = cleanuppad []
-  br label %shared
-right:
-  catchpad []
-    to label %right.catch unwind label %right.end
-right.catch:
-  br label %shared
-right.end:
-  catchendpad unwind to caller
-shared:
-  invoke void @f()
-    to label %unreachable unwind label %inner
-unreachable:
-  unreachable
-inner:
-  %i = cleanuppad []
-  invoke void @f()
-    to label %unreachable unwind label %inner.cleanup
-inner.cleanup:
-  cleanuppad []
-  call void @f()
-  unreachable
-exit:
-  ret void
-}
-; This tests the case where a funclet with multiple parents contains an invoke
-; instruction that unwinds to a child funclet.  Here %left and %right are both
-; parents of %inner.  Initially %inner is the only parent of %inner.cleanup but
-; after %inner is cloned, %inner.cleanup has multiple parents and so it must
-; also be cloned.
-; CHECK-LABEL: define void @test20(
-; CHECK:     left:
-; CHECK:       %l = cleanuppad []
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_LEFT:.+]] unwind label %[[INNER_LEFT:.+]]
-; CHECK:     right:
-; CHECK:       catchpad []
-; CHECK:           to label %[[RIGHT_CATCH:.+]] unwind label %[[RIGHT_END:.+]]
-; CHECK:     [[RIGHT_CATCH]]:
-; CHECK:       invoke void @f()
-; CHECK:           to label %[[SHARED_CONT_RIGHT:.+]] unwind label %[[INNER_RIGHT:.+]]
-; CHECK:     [[RIGHT_END]]:
-; CHECK:       catchendpad unwind to caller
-; CHECK:     [[SHARED_CONT_RIGHT]]:
-; CHECK:       unreachable
-; CHECK:     [[SHARED_CONT_LEFT]]:
-; CHECK:       unreachable
-; CHECK:     [[INNER_RIGHT]]:
-; CHECK:       [[I_RIGHT:\%.+]] = cleanuppad []
-; CHECK:       invoke void @f()
-; CHECK:         to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[INNER_CLEANUP_RIGHT:.+]]
-; CHECK:     [[INNER_LEFT]]:
-; CHECK:       [[I_LEFT:\%.+]] = cleanuppad []
-; CHECK:       invoke void @f()
-; CHECK:         to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[INNER_CLEANUP_LEFT:.+]]
-; CHECK:     [[INNER_CLEANUP_RIGHT]]:
-; CHECK:       cleanuppad []
-; CHECK:       call void @f()
-; CHECK:       unreachable
-; CHECK:     [[INNER_CLEANUP_LEFT]]:
-; CHECK:       cleanuppad []
-; CHECK:       call void @f()
-; CHECK:       unreachable
-
-

llvm/trunk/test/CodeGen/WinEH/wineh-no-demotion.ll

 ; RUN: opt -mtriple=x86_x64-pc-windows-msvc -S -winehprepare -disable-demotion < %s | FileCheck %s
 
 declare i32 @__CxxFrameHandler3(...)
 
+declare i32 @__C_specific_handler(...)
+
 declare void @f()
 
 declare i32 @g()
 
 declare void @h(i32)
 
 ; CHECK-LABEL: @test1(
-define void @test1() personality i32 (...)* @__CxxFrameHandler3 {
+define void @test1() personality i32 (...)* @__C_specific_handler {
 entry:
   invoke void @f()
           to label %invoke.cont1 unwind label %left
 
 invoke.cont1:
   invoke void @f()
           to label %invoke.cont2 unwind label %right
 
 invoke.cont2:
   invoke void @f()
           to label %exit unwind label %inner
 
 left:
-  %0 = cleanuppad []
+  %0 = cleanuppad within none []
   br label %shared
 
 right:
-  %1 = cleanuppad []
+  %1 = cleanuppad within none []
   br label %shared
 
 shared:
   %x = call i32 @g()
   invoke void @f()
           to label %shared.cont unwind label %inner
 
 shared.cont:
   unreachable
 
 inner:
   %phi = phi i32 [ %x, %shared ], [ 0, %invoke.cont2 ]
-  %i = cleanuppad []
+  %i = cleanuppad within none []
   call void @h(i32 %phi)
   unreachable
 
-; CHECK [[INNER_INVOKE_CONT2:inner.*]]:
-  ; CHECK: call void @h(i32 0)
-
-; CHECK [[INNER_RIGHT:inner.*]]:
-  ; CHECK: call void @h(i32 %x)
-
-; CHECK [[INNER_LEFT:inner.*]]:
-  ; CHECK: call void @h(i32 %x.for.left)
+; CHECK: %phi = phi i32 [ %x, %right ], [ 0, %invoke.cont2 ], [ %x.for.left, %left ]
+; CHECK: %i = cleanuppad within none []
+; CHECK: call void @h(i32 %phi)
 
 exit:
   unreachable
 }
 
 ; CHECK-LABEL: @test2(
-define void @test2() personality i32 (...)* @__CxxFrameHandler3 {
+define void @test2() personality i32 (...)* @__C_specific_handler {
 entry:
   invoke void @f()
           to label %invoke.cont unwind label %left
 
 invoke.cont:
   invoke void @f()
           to label %exit unwind label %right
 
 left:
-  cleanuppad []
+  cleanuppad within none []
   br label %shared
 
 right:
-  cleanuppad []
+  cleanuppad within none []
   br label %shared
 
 shared:
   %x = call i32 @g()
   invoke void @f()
           to label %shared.cont unwind label %inner
 
 shared.cont:
   unreachable
 
 inner:
-  %i = cleanuppad []
+  %i = cleanuppad within none []
   call void @h(i32 %x)
   unreachable
 
-; CHECK [[INNER_RIGHT:inner.*]]:
-  ; CHECK: call void @h(i32 %x)
-
-; CHECK [[INNER_LEFT:inner.*]]:
-  ; CHECK: call void @h(i32 %x.for.left)
+; CHECK:  %x1 = phi i32 [ %x.for.left, %left ], [ %x, %right ]
+; CHECK:  %i = cleanuppad within none []
+; CHECK:  call void @h(i32 %x1)
 
 exit:
   unreachable
 }
 
 ; CHECK-LABEL: @test3(
 define void @test3() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   invoke void @f()
           to label %invoke.cont unwind label %terminate
 
 invoke.cont:
   ret void
 
 terminate:
-; CHECK:  cleanuppad []
+; CHECK:  cleanuppad within none []
 ; CHECK:  call void @__std_terminate()
 ; CHECK:  unreachable
-  terminatepad [void ()* @__std_terminate] unwind to caller
+  terminatepad within none [void ()* @__std_terminate] unwind to caller
+}
+
+; CHECK-LABEL: @test4(
+define void @test4(i1 %x) personality i32 (...)* @__CxxFrameHandler3 {
+entry:
+  invoke void @f()
+          to label %invoke.cont1 unwind label %left
+
+invoke.cont1:
+  invoke void @f()
+          to label %exit unwind label %right
+
+left:
+  %0 = cleanuppad within none []
+  br label %shared
+
+right:
+  %1 = cleanuppad within none []
+  br i1 %x, label %shared, label %right.other
+
+right.other:
+  br label %shared
+
+shared:
+  %phi = phi i32 [ 1, %left ], [ 0, %right ], [ -1, %right.other ]
+  call void @h(i32 %phi)
+  unreachable
+
+; CHECK: %0 = cleanuppad within none []
+; CHECK: call void @h(i32 1)
+
+; CHECK: %1 = cleanuppad within none []
+; CHECK: %phi = phi i32 [ 0, %right ], [ -1, %right.other ]
+; CHECK: call void @h(i32 %phi)
+
+exit:
+  unreachable
 }
 
 declare void @__std_terminate()

llvm/trunk/test/CodeGen/WinEH/wineh-statenumbering-cleanups.ll

 ; RUN: sed -e s/.Cxx:// %s | opt -mtriple=x86-pc-windows-msvc -S -x86-winehstate | FileCheck %s
 ; RUN: sed -e s/.SEH:// %s | opt -mtriple=x86-pc-windows-msvc -S -x86-winehstate | FileCheck %s
 
 declare i32 @__CxxFrameHandler3(...)
 declare i32 @_except_handler3(...)
 declare void @dummy_filter()
 
 declare void @f(i32)
 
-; CHECK-LABEL: define void @test1(
-;Cxx: define void @test1() personality i32 (...)* @__CxxFrameHandler3 {
-;SEH: define void @test1() personality i32 (...)* @_except_handler3 {
-entry:
-  ; CHECK: entry:
-  ; CHECK:  store i32 0
-  ; CHECK:  invoke void @f(i32 0)
-  invoke void @f(i32 0)
-    to label %exit unwind label %cleanup.pad
-cleanup.pad:
-  ; CHECK: cleanup.pad:
-  ; CHECK:   store i32 1
-  ; CHECK:   invoke void @f(i32 1)
-  %cleanup = cleanuppad []
-  invoke void @f(i32 1)
-    to label %cleanup.ret unwind label %catch.pad
-catch.pad:
-;Cxx: %catch = catchpad [i8* null, i32 u0x40, i8* null]
-;SEH: %catch = catchpad [void ()* @dummy_filter]
-        to label %catch.body unwind label %catch.end
-catch.body:
-  catchret %catch to label %cleanup.ret
-catch.end:
-  catchendpad unwind label %cleanup.end
-cleanup.ret:
-  cleanupret %cleanup unwind to caller
-cleanup.end:
-  cleanupendpad %cleanup unwind to caller
-exit:
-  ret void
-}
-
 ; CHECK-LABEL: define void @test2(
 ;Cxx: define void @test2(i1 %b) personality i32 (...)* @__CxxFrameHandler3 {
 ;SEH: define void @test2(i1 %b) personality i32 (...)* @_except_handler3 {
 entry:
   ; CHECK: entry:
   ; CHECK:   store i32 1
   ; CHECK:   invoke void @f(i32 1)
   invoke void @f(i32 1)
     to label %exit unwind label %cleanup.pad
 cleanup.pad:
-  %cleanup = cleanuppad []
+  %cleanup = cleanuppad within none []
   br i1 %b, label %left, label %right
 left:
-  cleanupret %cleanup unwind label %catch.pad
+  cleanupret from %cleanup unwind label %catch.pad
 right:
-  cleanupret %cleanup unwind label %catch.pad
+  cleanupret from %cleanup unwind label %catch.pad
 catch.pad:
-;Cxx: %catch = catchpad [i8* null, i32 u0x40, i8* null]
-;SEH: %catch = catchpad [void ()* @dummy_filter]
-        to label %catch.body unwind label %catch.end
+  %cs1 = catchswitch within none [label %catch.body] unwind to caller
 catch.body:
-  catchret %catch to label %exit
-catch.end:
-  catchendpad unwind to caller
+;Cxx: %catch = catchpad within %cs1 [i8* null, i32 u0x40, i8* null]
+;SEH: %catch = catchpad within %cs1 [void ()* @dummy_filter]
+  catchret from %catch to label %exit
 exit:
   ret void
 }
 
 ; CHECK-LABEL: define void @test3(
 ;Cxx: define void @test3() personality i32 (...)* @__CxxFrameHandler3 {
 ;SEH: define void @test3() personality i32 (...)* @_except_handler3 {
 entry:
   ; CHECK: entry:
-  ; CHECK:   store i32 1
+  ; CHECK:   store i32 0
   ; CHECK:   invoke void @f(i32 1)
   invoke void @f(i32 1)
     to label %exit unwind label %cleanup.pad
 cleanup.pad:
   ; CHECK: cleanup.pad:
-  ; CHECK:   store i32 0
+  ; CHECK:   store i32 1
   ; CHECK:   invoke void @f(i32 0)
-  %cleanup = cleanuppad []
+  %cleanup = cleanuppad within none []
   invoke void @f(i32 0)
-    to label %unreachable unwind label %cleanup.end
+    to label %unreachable unwind label %catch.pad
 unreachable:
   unreachable
-cleanup.end:
-  cleanupendpad %cleanup unwind label %catch.pad
 catch.pad:
-;Cxx: %catch = catchpad [i8* null, i32 u0x40, i8* null]
-;SEH: %catch = catchpad [void ()* @dummy_filter]
-        to label %catch.body unwind label %catch.end
+  %cs1 = catchswitch within none [label %catch.body] unwind to caller
 catch.body:
-  catchret %catch to label %exit
-catch.end:
-  catchendpad unwind to caller
+;Cxx: %catch = catchpad within %cs1 [i8* null, i32 u0x40, i8* null]
+;SEH: %catch = catchpad within %cs1 [void ()* @dummy_filter]
+  catchret from %catch to label %exit
 exit:
   ret void
 }

llvm/trunk/test/CodeGen/WinEH/wineh-statenumbering.ll

entry:
   store i32 0, i32* %tmp, align 4
   %0 = bitcast i32* %tmp to i8*
   ; CHECK:   store i32 0
   ; CHECK:   invoke void @_CxxThrowException(
   invoke void @_CxxThrowException(i8* %0, %eh.ThrowInfo* nonnull @_TI1H) #1
           to label %unreachable.for.entry unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %1 = catchpad [i8* null, i32 u0x40, i8* null] to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:                                            ; preds = %catch.dispatch
+  %1 = catchpad within %cs1 [i8* null, i32 u0x40, i8* null]
   ; CHECK: catch:
   ; CHECK:   store i32 2
   ; CHECK:   invoke void @_CxxThrowException(
   invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null) #1
           to label %unreachable unwind label %catch.dispatch.1
 
 catch.dispatch.1:                                 ; preds = %catch
-  %2 = catchpad [i8* null, i32 u0x40, i8* null] to label %catch.3 unwind label %catchendblock.2
-
+  %cs2 = catchswitch within %1 [label %catch.3] unwind to caller
 catch.3:                                          ; preds = %catch.dispatch.1
+  %2 = catchpad within %cs2 [i8* null, i32 u0x40, i8* null]
   ; CHECK: catch.3:
   ; CHECK:   store i32 3
-  ; CHECK:   invoke void @g(i32 1)
-  invoke void @g(i32 1)
-          to label %invoke.cont unwind label %catchendblock.2
-
-invoke.cont:                                      ; preds = %catch.3
-  catchret %2 to label %try.cont
+  ; CHECK:   call void @g(i32 1)
+  call void @g(i32 1)
+  catchret from %2 to label %try.cont
 
-try.cont:                                         ; preds = %invoke.cont
+try.cont:                                         ; preds = %catch.3
   ; CHECK: try.cont:
   ; CHECK:   store i32 1
-  ; CHECK:   invoke void @g(i32 2)
-  invoke void @g(i32 2)
-          to label %invoke.cont.4 unwind label %catchendblock
-
-invoke.cont.4:                                    ; preds = %try.cont
+  ; CHECK:   call void @g(i32 2)
+  call void @g(i32 2)
   unreachable
 
-catchendblock.2:                                  ; preds = %catch.3, %catch.dispatch.1
-  catchendpad unwind label %catchendblock
-
-catchendblock:                                    ; preds = %catchendblock.2, %try.cont, %catch.dispatch
-  catchendpad unwind to caller
-
 unreachable:                                      ; preds = %catch
   unreachable
 
 unreachable.for.entry:                            ; preds = %entry
   unreachable
 }
 
 define i32 @nopads() #0 personality i32 (...)* @__CxxFrameHandler3 {

llvm/trunk/test/CodeGen/X86/branchfolding-catchpads.ll

if.then:
   %call1 = invoke i16 @f()
           to label %cleanup unwind label %catch.dispatch
 
 if.else:
   %call2 = invoke i16 @f()
           to label %cleanup unwind label %catch.dispatch
 
 catch.dispatch:
-  catchpad [i8* null, i32 8, i8* null]
-          to label %catch unwind label %catch.dispatch.2
+  %cs = catchswitch within none [ label %catch, label %catch.2 ] unwind to caller
 
 catch:
-  invoke void @throw() noreturn
-          to label %unreachable unwind label %catchendblock
-
-catch.dispatch.2:
-  catchpad [i8* null, i32 64, i8* null]
-          to label %catch.2 unwind label %catchendblock
+  catchpad within %cs [i8* null, i32 8, i8* null]
+  call void @throw() noreturn
+  br label %unreachable
 
 catch.2:
+  catchpad within %cs [i8* null, i32 64, i8* null]
   store i8 1, i8* %b
-  invoke void @throw() noreturn
-          to label %unreachable unwind label %catchendblock
-
-catchendblock:
-  catchendpad unwind to caller
+  call void @throw() noreturn
+  br label %unreachable
 
 cleanup:
   %retval = phi i16 [ %call1, %if.then ], [ %call2, %if.else ]
   ret i16 %retval
 
 unreachable:
   unreachable
 }
if.then:
   %call1 = invoke i16 @f()
           to label %cleanup unwind label %catch.dispatch
 
 if.else:
   %call2 = invoke i16 @f()
           to label %cleanup unwind label %catch.dispatch
 
 catch.dispatch:
-  catchpad [i8* null, i32 8, i8* null]
-          to label %catch unwind label %catch.dispatch.2
+  %cs = catchswitch within none [ label %catch, label %catch.2, label %catch.3 ] unwind to caller
 
 catch:
-  invoke void @throw() noreturn
-          to label %unreachable unwind label %catchendblock
-
-catch.dispatch.2:
-  %c2 = catchpad [i8* null, i32 32, i8* null]
-          to label %catch.2 unwind label %catch.dispatch.3
+  catchpad within %cs [i8* null, i32 8, i8* null]
+  call void @throw() noreturn
+  br label %unreachable
 
 catch.2:
+  %c2 = catchpad within %cs [i8* null, i32 32, i8* null]
   store i8 1, i8* %b
-  catchret %c2 to label %cleanup
-
-catch.dispatch.3:
-  %c3 = catchpad [i8* null, i32 64, i8* null]
-          to label %catch.3 unwind label %catchendblock
+  catchret from %c2 to label %cleanup
 
 catch.3:
+  %c3 = catchpad within %cs [i8* null, i32 64, i8* null]
   store i8 2, i8* %b
-  catchret %c3 to label %cleanup
-
-catchendblock:
-  catchendpad unwind to caller
+  catchret from %c3 to label %cleanup
 
 cleanup:
   %retval = phi i16 [ %call1, %if.then ], [ %call2, %if.else ], [ -1, %catch.2 ], [ -1, %catch.3 ]
   ret i16 %retval
 
 unreachable:
   unreachable
 }
 
 ; This test verifies the case where three funclet blocks all meet the old
 ; criteria to be placed at the end.  The order of the blocks is not important
 ; for the purposes of this test.  The failure mode is an infinite loop during
 ; compilation.
 ;
 ; CHECK-LABEL: .def     test2;
 

llvm/trunk/test/CodeGen/X86/catchpad-realign-savexmm.ll

 ; RUN: llc -mtriple=x86_64-pc-windows-msvc -verify-machineinstrs < %s | FileCheck %s
 
 ; We should store -2 into UnwindHelp in a slot immediately after the last XMM
 ; CSR save.
 
 declare void @g()
 declare i32 @__CxxFrameHandler3(...)
 
 @fp_global = global double 0.0
 
 define void @f() personality i32 (...)* @__CxxFrameHandler3 {
   %v = load double, double* @fp_global
   call void @g()
   %v1 = fadd double %v, 1.0
   store double %v1, double* @fp_global
   invoke void @g()
-      to label %return unwind label %catch
+      to label %return unwind label %catch.dispatch
 
 return:
   ret void
 
-catch:
-  %p = catchpad [i8* null, i32 64, i8* null]
-      to label %catchit unwind label %endpad
+catch.dispatch:
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
-catchit:
-  catchret %p to label %return
-endpad:
-  catchendpad unwind to caller
+catch:
+  %p = catchpad within %cs1 [i8* null, i32 64, i8* null]
+  catchret from %p to label %return
 }
 
 ; CHECK: f: # @f
 ; CHECK: pushq   %rbp
 ; CHECK: .seh_pushreg 5
 ; CHECK: subq    $64, %rsp
 ; CHECK: .seh_stackalloc 64
 ; CHECK: leaq    64(%rsp), %rbp

llvm/trunk/test/CodeGen/X86/catchpad-regmask.ll

 entry:
   %idxprom = sext i32 %idx1 to i64
   %arrayidx = getelementptr inbounds [4 x i32], [4 x i32]* @array, i64 0, i64 %idxprom
   store i32 111, i32* %arrayidx, align 4, !tbaa !2
   invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null) #1
           to label %unreachable unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %0 = catchpad [i8* null, i32 64, i8* null]
-          to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:                                            ; preds = %catch.dispatch
+  %0 = catchpad within %cs1 [i8* null, i32 64, i8* null]
   %idxprom1 = sext i32 %idx2 to i64
   %arrayidx2 = getelementptr inbounds [4 x i32], [4 x i32]* @array, i64 0, i64 %idxprom1
   store i32 222, i32* %arrayidx2, align 4, !tbaa !2
-  catchret %0 to label %try.cont
+  catchret from %0 to label %try.cont
 
 try.cont:                                         ; preds = %catch
   %idxprom3 = sext i32 %idx3 to i64
   %arrayidx4 = getelementptr inbounds [4 x i32], [4 x i32]* @array, i64 0, i64 %idxprom3
   store i32 333, i32* %arrayidx4, align 4, !tbaa !2
   ret void
 
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind to caller
-
 unreachable:                                      ; preds = %entry
   unreachable
 }
 
 ; CHECK-LABEL: global_array: # @global_array
 ; CHECK: pushq %rbp
 ;   First array access
 ; CHECK: movslq  %ecx, %[[idx:[^ ]*]]

 ; Function Attrs: uwtable
 define void @access_imported() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   store i32 111, i32* @imported, align 4, !tbaa !2
   invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null) #1
           to label %unreachable unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %0 = catchpad [i8* null, i32 64, i8* null]
-          to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:                                            ; preds = %catch.dispatch
+  %0 = catchpad within %cs1 [i8* null, i32 64, i8* null]
   store i32 222, i32* @imported, align 4, !tbaa !2
-  catchret %0 to label %try.cont
+  catchret from %0 to label %try.cont
 
 try.cont:                                         ; preds = %catch
   store i32 333, i32* @imported, align 4, !tbaa !2
   ret void
 
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind to caller
-
 unreachable:                                      ; preds = %entry
   unreachable
 }
 
 ; CHECK-LABEL: access_imported: # @access_imported
 ; CHECK: pushq %rbp
 ; CHECK: movq    __imp_imported(%rip), %[[base:[^ ]*]]
 ; CHECK: movl    $111, (%[[base]])

llvm/trunk/test/CodeGen/X86/catchpad-weight.ll

 ; RUN: llc -march=x86-64 -print-machineinstrs=expand-isel-pseudos %s -o /dev/null 2>&1 | FileCheck %s
 
 ; Check if the edge weight to the catchpad is calculated correctly.
 
-; CHECK: Successors according to CFG: BB#3(0x7ffff100 / 0x80000000 = 100.00%) BB#1(0x00000800 / 0x80000000 = 0.00%) BB#4(0x00000400 / 0x80000000 = 0.00%) BB#6(0x00000200 / 0x80000000 = 0.00%) BB#8(0x00000100 / 0x80000000 = 0.00%)
+; CHECK: Successors according to CFG: BB#2(0x7ffff100 / 0x80000000 = 100.00%) BB#1(0x00000800 / 0x80000000 = 0.00%) BB#3(0x00000400 / 0x80000000 = 0.00%) BB#4(0x00000200 / 0x80000000 = 0.00%) BB#5(0x00000100 / 0x80000000 = 0.00%)
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64--windows-msvc18.0.0"
 
 %rtti.TypeDescriptor7 = type { i8**, i8*, [8 x i8] }
 %struct.HasDtor = type { i8 }
 
 $"\01??_R0?AUA@@@8" = comdat any

 entry:
   %o = alloca %struct.HasDtor, align 1
   %0 = getelementptr inbounds %struct.HasDtor, %struct.HasDtor* %o, i64 0, i32 0
   call void @llvm.lifetime.start(i64 1, i8* %0) #4
   invoke void @"\01?may_throw@@YAXXZ"()
           to label %try.cont unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %1 = catchpad [%rtti.TypeDescriptor7* @"\01??_R0?AUA@@@8", i32 0, i8* null]
-          to label %catch.5 unwind label %catch.dispatch.1
+  %cs1 = catchswitch within none [label %catch.5] unwind label %catch.dispatch.1
 
 catch.5:                                          ; preds = %catch.dispatch
-  catchret %1 to label %try.cont
+  %1 = catchpad within %cs1 [%rtti.TypeDescriptor7* @"\01??_R0?AUA@@@8", i32 0, i8* null]
+  catchret from %1 to label %try.cont
 
 try.cont:                                         ; preds = %entry, %catch, %catch.3, %catch.5
   call void @"\01??1HasDtor@@QEAA@XZ"(%struct.HasDtor* nonnull %o) #4
   call void @llvm.lifetime.end(i64 1, i8* %0) #4
   ret i32 0
 
 catch.dispatch.1:                                 ; preds = %catch.dispatch
-  %2 = catchpad [%rtti.TypeDescriptor7* @"\01??_R0?AUB@@@8", i32 0, i8* null]
-          to label %catch.3 unwind label %catch.dispatch.2
+  %cs2 = catchswitch within none [label %catch.3] unwind label %catch.dispatch.2
 
 catch.3:                                          ; preds = %catch.dispatch.1
-  catchret %2 to label %try.cont
+  %2 = catchpad within %cs2 [%rtti.TypeDescriptor7* @"\01??_R0?AUB@@@8", i32 0, i8* null]
+  catchret from %2 to label %try.cont
 
 catch.dispatch.2:                                 ; preds = %catch.dispatch.1
-  %3 = catchpad [%rtti.TypeDescriptor7* @"\01??_R0?AUC@@@8", i32 0, i8* null]
-          to label %catch unwind label %catchendblock
+  %cs3 = catchswitch within none [label %catch] unwind label %ehcleanup
 
 catch:                                            ; preds = %catch.dispatch.2
-  catchret %3 to label %try.cont
-
-catchendblock:                                    ; preds = %catch.dispatch.2
-  catchendpad unwind label %ehcleanup
+  %3 = catchpad within %cs3 [%rtti.TypeDescriptor7* @"\01??_R0?AUC@@@8", i32 0, i8* null]
+  catchret from %3 to label %try.cont
 
 ehcleanup:                                        ; preds = %catchendblock
-  %4 = cleanuppad []
+  %4 = cleanuppad within none []
   call void @"\01??1HasDtor@@QEAA@XZ"(%struct.HasDtor* nonnull %o) #4
-  cleanupret %4 unwind to caller
+  cleanupret from %4 unwind to caller
 }
 
 ; Function Attrs: nounwind argmemonly
 declare void @llvm.lifetime.start(i64, i8* nocapture) #1
 
 declare void @"\01?may_throw@@YAXXZ"() #2
 
 declare i32 @__CxxFrameHandler3(...)

llvm/trunk/test/CodeGen/X86/catchret-empty-fallthrough.ll

 entry:
   br i1 %cond, label %return, label %try
 
 try:                                              ; preds = %entry
   invoke void @bar()
           to label %fallthrough unwind label %dispatch
 
 dispatch:                                         ; preds = %try
-  %0 = catchpad [i8* null]
-          to label %catch unwind label %catchendblock.i.i
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:                                            ; preds = %dispatch
-  catchret %0 to label %return
-
-catchendblock.i.i:                                ; preds = %dispatch
-  catchendpad unwind to caller
+  %0 = catchpad within %cs1 [i8* null]
+  catchret from %0 to label %return
 
 fallthrough:                                      ; preds = %try
   unreachable
 
 return:                                           ; preds = %catch, %entry
   ret void
 }
 

llvm/trunk/test/CodeGen/X86/catchret-fallthrough.ll

 declare void @g()
 
 define void @f() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   invoke void @g()
           to label %invoke.cont.3 unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %0 = catchpad [i8* null, i32 64, i8* null]
-          to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:                                            ; preds = %catch.dispatch
-  catchret %0 to label %nrvo.skipdtor
-
-catchendblock:                                    ; preds = %catch, %catch.dispatch
-  catchendpad unwind to caller
+  %0 = catchpad within %cs1 [i8* null, i32 64, i8* null]
+  catchret from %0 to label %nrvo.skipdtor
 
 invoke.cont.3:                                    ; preds = %entry
   store i32 123, i32* @some_global
   br label %nrvo.skipdtor
 
 nrvo.skipdtor:                                    ; preds = %invoke.cont.3, %invoke.cont.4
   ret void
 }

llvm/trunk/test/CodeGen/X86/cleanuppad-inalloca.ll

entry:
   %call1 = invoke x86_thiscallcc %struct.A* @"\01??0A@@QAE@XZ"(%struct.A* %1)
           to label %invoke.cont unwind label %ehcleanup
 
 invoke.cont:                                      ; preds = %entry
   call void @takes_two(<{ %struct.A, %struct.A }>* inalloca nonnull %argmem)
   ret void
 
 ehcleanup:                                        ; preds = %entry
-  %2 = cleanuppad []
+  %2 = cleanuppad within none []
   call x86_thiscallcc void @"\01??1A@@QAE@XZ"(%struct.A* %0)
-  cleanupret %2 unwind to caller
+  cleanupret from %2 unwind to caller
 }
 
 ; CHECK: _passes_two:
 ; CHECK: pushl %ebp
 ; CHECK: movl %esp, %ebp
 ; CHECK: subl ${{[0-9]+}}, %esp
 ; CHECK: movl $8, %eax
 ; CHECK: calll __chkstk

llvm/trunk/test/CodeGen/X86/cleanuppad-large-codemodel.ll

 ; RUN: llc -mtriple=x86_64-pc-windows-msvc -code-model=large -o - < %s | FileCheck %s
 
 declare i32 @__CxxFrameHandler3(...)
 
 declare void @bar()
 
 define void @foo() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   invoke void @bar()
     to label %exit unwind label %cleanup
 cleanup:
-  %c = cleanuppad []
+  %c = cleanuppad within none []
   call void @bar()
-  cleanupret %c unwind to caller
+  cleanupret from %c unwind to caller
 exit:
   ret void
 }
 
 ; CHECK: foo: # @foo
 ; CHECK: movabsq $bar, %[[reg:[^ ]*]]
 ; CHECK: callq *%[[reg]]
 ; CHECK: retq
 
 ; CHECK: "?dtor$2@?0?foo@4HA":
 ; CHECK: movabsq $bar, %[[reg:[^ ]*]]
 ; CHECK: callq *%[[reg]]
 ; CHECK: retq                            # CLEANUPRET

llvm/trunk/test/CodeGen/X86/cleanuppad-realign.ll

entry:
   invoke void @f(i32 1)
           to label %invoke.cont unwind label %ehcleanup
 
 invoke.cont:                                      ; preds = %entry
   call void @Dtor(i64* %o)
   ret void
 
 ehcleanup:                                        ; preds = %entry
-  %0 = cleanuppad []
+  %0 = cleanuppad within none []
   call void @Dtor(i64* %o)
-  cleanupret %0 unwind to caller
+  cleanupret from %0 unwind to caller
 }
 
 ; X86-LABEL: _realigned_cleanup: # @realigned_cleanup
 ; X86:         pushl   %ebp
 ; X86:         movl    %esp, %ebp
 ; X86:         pushl   %ebx
 ; X86:         pushl   %edi
 ; X86:         pushl   %esi

llvm/trunk/test/CodeGen/X86/funclet-layout.ll

 @"\01??_R0H@8" = internal global %rtti.TypeDescriptor2 { i8** @"\01??_7type_info@@6B@", i8* null, [3 x i8] c".H\00" }
 
 define void @test1(i1 %B) personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   invoke void @g()
           to label %unreachable unwind label %catch.dispatch
 
 catch.dispatch:
-  %cp = catchpad [i8* null, i32 64, i8* null]
-          to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:
-  br i1 %B, label %catchret, label %catch
+  %cp = catchpad within %cs1 [i8* null, i32 64, i8* null]
+  br label %catch.loop
+
+catch.loop:
+  br i1 %B, label %catchret, label %catch.loop
 
 catchret:
-  catchret %cp to label %try.cont
+  catchret from %cp to label %try.cont
 
 try.cont:
   ret void
 
-catchendblock:
-  catchendpad unwind to caller
-
 unreachable:
   unreachable
 }
 
 ; CHECK-LABEL: test1:
 
 ; The entry funclet contains %entry and %try.cont
 ; CHECK: # %entry

 
 
 define i32 @test2(i1 %B) personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null) #1
           to label %unreachable unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %0 = catchpad [i8* null, i32 64, i8* null]
-          to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:                                            ; preds = %catch.dispatch
+  %0 = catchpad within %cs1 [i8* null, i32 64, i8* null]
   invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null) #1
           to label %unreachable unwind label %catch.dispatch.1
 
 catch.dispatch.1:                                 ; preds = %catch
-  %1 = catchpad [i8* null, i32 64, i8* null]
-          to label %catch.3 unwind label %catchendblock.2
+  %cs2 = catchswitch within %0 [label %catch.3] unwind to caller
 
 catch.3:                                          ; preds = %catch.dispatch.1
-  catchret %1 to label %try.cont
+  %1 = catchpad within %cs2 [i8* null, i32 64, i8* null]
+  catchret from %1 to label %try.cont
 
 try.cont:                                         ; preds = %catch.3
-  catchret %0 to label %try.cont.5
+  catchret from %0 to label %try.cont.5
 
 try.cont.5:                                       ; preds = %try.cont
   ret i32 0
 
-catchendblock.2:                                  ; preds = %catch.dispatch.1
-  catchendpad unwind label %catchendblock
-
-catchendblock:                                    ; preds = %catchendblock.2, %catch.dispatch
-  catchendpad unwind to caller
-
 unreachable:                                      ; preds = %catch, %entry
   unreachable
-
 }
 
 ; CHECK-LABEL: test2:
 
-; The entry funclet contains %entry and %try.cont.5
+; The parent function contains %entry and %try.cont.5
+; CHECK: .seh_proc
 ; CHECK: # %entry
 ; CHECK: # %try.cont.5
 ; CHECK: retq
 
-; The outer catch funclet contains %catch.dispatch
-; CHECK: # %catch.dispatch{{$}}
+; The inner catch funclet contains %catch.3
+; CHECK: .seh_proc
+; CHECK: # %catch.3{{$}}
+; CHECK: retq
+
+; The outer catch funclet contains %catch
+; CHECK: .seh_proc
+; CHECK: # %catch{{$}}
 ; CHECK: callq _CxxThrowException
 ; CHECK: # %unreachable
 ; CHECK: ud2
 
-; The inner catch funclet contains %catch.dispatch.1
-; CHECK: # %catch.dispatch.1
-; CHECK: retq
-
 
 define void @test3(i1 %V) #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   invoke void @g()
           to label %try.cont unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %0 = catchpad [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
-          to label %catch.2 unwind label %catch.dispatch.1
+  %cs1 = catchswitch within none [label %catch.2] unwind label %catch.dispatch.1
 
 catch.2:                                          ; preds = %catch.dispatch
+  %0 = catchpad within %cs1 [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
   tail call void @exit(i32 0) #2
   unreachable
 
 catch.dispatch.1:                                 ; preds = %catch.dispatch
-  %1 = catchpad [i8* null, i32 64, i8* null]
-          to label %catch unwind label %catchendblock
+  %cs2 = catchswitch within none [label %catch] unwind to caller
 
 catch:                                            ; preds = %catch.dispatch.1
+  %1 = catchpad within %cs2 [i8* null, i32 64, i8* null]
   tail call void @exit(i32 0) #2
   unreachable
 
-catchendblock:                                    ; preds = %catch.dispatch.1
-  catchendpad unwind to caller
-
 try.cont:                                         ; preds = %entry
   br i1 %V, label %exit_one, label %exit_two
 
 exit_one:
   tail call void @exit(i32 0)
   unreachable
 
 exit_two:
   tail call void @exit(i32 0)
   unreachable
 }
 
 ; CHECK-LABEL: test3:
 
 ; The entry funclet contains %entry and %try.cont
 ; CHECK: # %entry
 ; CHECK: # %try.cont
 ; CHECK: callq exit
 ; CHECK-NOT: # exit_one
 ; CHECK-NOT: # exit_two
 ; CHECK: ud2
 
-; The catch(...) funclet contains %catch.dispatch
-; CHECK: # %catch.dispatch{{$}}
+; The catch(...) funclet contains %catch.2
+; CHECK: # %catch.2{{$}}
 ; CHECK: callq exit
 ; CHECK: ud2
 
-; The catch(int) funclet contains %catch.dispatch.1
-; CHECK: # %catch.dispatch.1
+; The catch(int) funclet contains %catch
+; CHECK: # %catch{{$}}
 ; CHECK: callq exit
 ; CHECK: ud2
 
 declare void @exit(i32) noreturn nounwind
 declare void @_CxxThrowException(i8*, %eh.ThrowInfo*)
 declare i32 @__CxxFrameHandler3(...)

llvm/trunk/test/CodeGen/X86/late-address-taken.ll

 entry:
   br i1 %b, label %body, label %early_out
 early_out:
   ret void
 body:
   invoke void @f()
           to label %exit unwind label %catch.pad
 catch.pad:
-  %catch = catchpad [i32 33554467]
-          to label %catch.body unwind label %catch.end
+  %cs1 = catchswitch within none [label %catch.body] unwind to caller
 catch.body:
-  catchret %catch to label %exit
-catch.end:
-  catchendpad unwind to caller
+  %catch = catchpad within %cs1 [i32 33554467]
+  catchret from %catch to label %exit
 exit:
   ret void
 }
 ; CHECK-LABEL: catchret:  # @catchret
 ; CHECK: [[Exit:^[^ :]+]]: # Block address taken
 ; CHECK-NEXT:              # %exit
-; CHECK: # %catch.pad
+; CHECK: # %catch.body
 ; CHECK: .seh_endprolog
 ; CHECK: leaq [[Exit]](%rip), %rax
 ; CHECK: retq # CATCHRET
 
 
 ; test @setjmp - similar to @catchret, but the MBB in question
 ; is the one generated when the setjmp's block is split
 

llvm/trunk/test/CodeGen/X86/seh-catch-all-win32.ll

 define i32 @main() personality i8* bitcast (i32 (...)* @_except_handler3 to i8*) {
 entry:
   %__exceptioncode = alloca i32, align 4
   call void (...) @llvm.localescape(i32* %__exceptioncode)
   invoke void @crash() #5
           to label %__try.cont unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %p = catchpad [i8* bitcast (i32 ()* @"filt$main" to i8*)]
-          to label %__except unwind label %endpad
+  %cs1 = catchswitch within none [label %__except] unwind to caller
 
 __except:                                         ; preds = %lpad
+  %p = catchpad within %cs1 [i8* bitcast (i32 ()* @"filt$main" to i8*)]
   %code = load i32, i32* %__exceptioncode, align 4
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @str, i32 0, i32 0), i32 %code) #4
-  catchret %p to label %__try.cont
-
-endpad:                                        ; preds = %lpad
-  catchendpad unwind to caller
+  catchret from %p to label %__try.cont
 
 __try.cont:                                       ; preds = %entry, %__except
   ret i32 0
 }
 
 define internal i32 @"filt$main"() {
 entry:
   %ebp = tail call i8* @llvm.frameaddress(i32 1)

 ; CHECK: movl $L__ehtable$main,
 ;       EH state 0
 ; CHECK: movl $0, -16(%ebp)
 ; CHECK: calll _crash
 ; CHECK: popl %esi
 ; CHECK: popl %edi
 ; CHECK: popl %ebx
 ; CHECK: retl
-; CHECK: LBB0_[[lpbb:[0-9]+]]: # %lpad{{$}}
+; CHECK: LBB0_[[lpbb:[0-9]+]]: # %__except{{$}}
 ;       stackrestore
 ; CHECK: movl -24(%ebp), %esp
 ;       EH state -1
 ; CHECK: movl [[code_offs]](%ebp), %[[code:[a-z]+]]
 ; CHECK-DAG: movl %[[code]], 4(%esp)
 ; CHECK-DAG: movl $_str, (%esp)
 ; CHECK: calll _printf
 

llvm/trunk/test/CodeGen/X86/seh-catch-all.ll

 entry:
   invoke void @crash()
           to label %__try.cont unwind label %lpad
 
 __try.cont:
   ret i32 0
 
 lpad:
-  %p = catchpad [i8* null, i32 64, i8* null]
-          to label %catchall unwind label %endpad
+  %cs1 = catchswitch within none [label %catchall] unwind to caller
 
 catchall:
+  %p = catchpad within %cs1 [i8* null, i32 64, i8* null]
   %code = call i32 @llvm.eh.exceptioncode(token %p)
   call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @str, i64 0, i64 0), i32 %code)
-  catchret %p to label %__try.cont
-
-endpad:
-  catchendpad unwind to caller
+  catchret from %p to label %__try.cont
 }
 
 ; Check that we can get the exception code from eax to the printf.
 
 ; CHECK-LABEL: main:
 ; CHECK: callq crash
 ; CHECK: retq
-; CHECK: .LBB0_2: # %lpad
+; CHECK: .LBB0_2: # %catchall
 ; CHECK: leaq str(%rip), %rcx
 ; CHECK: movl %eax, %edx
 ; CHECK: callq printf
 
 ; CHECK: .seh_handlerdata
 ; CHECK-NEXT: .long (.Llsda_end0-.Llsda_begin0)/16
 ; CHECK-NEXT: .Llsda_begin0:
 ; CHECK-NEXT: .long .Ltmp{{[0-9]+}}@IMGREL
 ; CHECK-NEXT: .long .Ltmp{{[0-9]+}}@IMGREL+1
 ; CHECK-NEXT: .long 1
 ; CHECK-NEXT: .long .LBB0_2@IMGREL
 ; CHECK-NEXT: .Llsda_end0:

llvm/trunk/test/CodeGen/X86/seh-catchpad.ll

entry:
   ret i32 %div
 }
 
 define i32 @main() #1 personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
 entry:
   %call = invoke i32 @do_div(i32 1, i32 0) #4
           to label %__try.cont.12 unwind label %catch.dispatch
 
-catch.dispatch:                                   ; preds = %entry
-  %0 = catchpad [i8* null]
-          to label %__except unwind label %catchendblock
-
-__except:                                         ; preds = %catch.dispatch
-  catchret %0 to label %__except.2
-
 __except.2:                                       ; preds = %__except
   %call4 = invoke i32 @do_div(i32 1, i32 0) #4
           to label %invoke.cont.3 unwind label %ehcleanup
 
 invoke.cont.3:                                    ; preds = %__except.2
   invoke fastcc void @"\01?fin$0@0@main@@"() #4
           to label %__try.cont.12 unwind label %catch.dispatch.7
 
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind label %catch.dispatch.7
-
-ehcleanup:                                        ; preds = %__except.2
-  %1 = cleanuppad []
-  invoke fastcc void @"\01?fin$0@0@main@@"() #4
-          to label %invoke.cont.6 unwind label %ehcleanup.end
-
-invoke.cont.6:                                    ; preds = %ehcleanup
-  cleanupret %1 unwind label %catch.dispatch.7
-
-catch.dispatch.7:                                 ; preds = %invoke.cont.3, %invoke.cont.6, %ehcleanup.end, %catchendblock
-  %2 = catchpad [i8* bitcast (i32 (i8*, i8*)* @"\01?filt$0@0@main@@" to i8*)]
-          to label %__except.ret unwind label %catchendblock.8
-
-__except.ret:                                     ; preds = %catch.dispatch.7
-  catchret %2 to label %__except.9
-
 __except.9:                                       ; preds = %__except.ret
   %call11 = tail call i32 @puts(i8* nonnull getelementptr inbounds ([7 x i8], [7 x i8]* @"\01??_C@_06IBDBCMGJ@caught?$AA@", i64 0, i64 0))
   br label %__try.cont.12
 
 __try.cont.12:                                    ; preds = %invoke.cont.3, %entry, %__except.9
   ret i32 0
 
-catchendblock.8:                                  ; preds = %catch.dispatch.7
-  catchendpad unwind to caller
+catch.dispatch:                                   ; preds = %entry
+  %cs1 = catchswitch within none [label %__except] unwind label %catch.dispatch.7
+
+__except:                                         ; preds = %catch.dispatch
+  %cp1 = catchpad within %cs1 [i8* null]
+  catchret from %cp1 to label %__except.2
 
-ehcleanup.end:                                    ; preds = %ehcleanup
-  cleanupendpad %1 unwind label %catch.dispatch.7
+ehcleanup:                                        ; preds = %__except.2
+  %cp2 = cleanuppad within none []
+  invoke fastcc void @"\01?fin$0@0@main@@"() #4
+          to label %invoke.cont.6 unwind label %catch.dispatch.7
+
+invoke.cont.6:                                    ; preds = %ehcleanup
+  cleanupret from %cp2 unwind label %catch.dispatch.7
+
+catch.dispatch.7:
+  %cs2 = catchswitch within none [label %__except.ret] unwind to caller
+
+__except.ret:                                     ; preds = %catch.dispatch.7
+  %cp3 = catchpad within %cs2 [i8* bitcast (i32 (i8*, i8*)* @"\01?filt$0@0@main@@" to i8*)]
+  catchret from %cp3 to label %__except.9
 }
 
 ; CHECK: main:                                   # @main
 ; CHECK: .seh_proc main
 ; CHECK:         .seh_handler __C_specific_handler, @unwind, @except
 ; CHECK:         pushq   %rbp
 ; CHECK:         .seh_pushreg 5
 ; CHECK:         subq    $32, %rsp
 ; CHECK:         .seh_stackalloc 32
 ; CHECK:         leaq    32(%rsp), %rbp
 ; CHECK:         .seh_setframe 5, 32
 ; CHECK:         .seh_endprologue
 ; CHECK: .Ltmp0:
 ; CHECK:         movl    $1, %ecx
 ; CHECK:         xorl    %edx, %edx
 ; CHECK:         callq   do_div
 ; CHECK: .Ltmp1:
 ; CHECK: .LBB1_[[epilogue:[0-9]+]]:                                # %__try.cont.12
 ; CHECK:         xorl    %eax, %eax
 ; CHECK:         addq    $32, %rsp
 ; CHECK:         popq    %rbp
 ; CHECK:         retq
-; CHECK: .LBB1_[[except1bb:[0-9]+]]:                                # %catch.dispatch
+; CHECK: .LBB1_[[except1bb:[0-9]+]]:                                # %__except
 ; CHECK: .Ltmp2:
 ; CHECK:         movl    $1, %ecx
 ; CHECK:         xorl    %edx, %edx
 ; CHECK:         callq   do_div
 ; CHECK: .Ltmp3:
 ; CHECK:         callq   "?fin$0@0@main@@"
 ; CHECK:         jmp     .LBB1_[[epilogue]]
-; CHECK: .LBB1_[[except2bb:[0-9]+]]:                                # %catch.dispatch.7
+; CHECK: .LBB1_[[except2bb:[0-9]+]]:                                # %__except.ret
 ; CHECK:         leaq    "??_C@_06IBDBCMGJ@caught?$AA@"(%rip), %rcx
 ; CHECK:         callq   puts
 ; CHECK:         jmp     .LBB1_[[epilogue]]
 
 ; CHECK:         .seh_handlerdata
 ; CHECK-NEXT:         .long   (.Llsda_end0-.Llsda_begin0)/16
 ; CHECK-NEXT: .Llsda_begin0:
 ; CHECK-NEXT:         .long   .Ltmp0@IMGREL+1
 ; CHECK-NEXT:         .long   .Ltmp1@IMGREL+1
 ; CHECK-NEXT:         .long   1
 ; CHECK-NEXT:         .long   .LBB1_[[except1bb]]@IMGREL
 ; CHECK-NEXT:         .long   .Ltmp0@IMGREL+1
 ; CHECK-NEXT:         .long   .Ltmp1@IMGREL+1
 ; CHECK-NEXT:         .long   "?filt$0@0@main@@"@IMGREL
 ; CHECK-NEXT:         .long   .LBB1_[[except2bb]]@IMGREL
 ; CHECK-NEXT:         .long   .Ltmp2@IMGREL+1
 ; CHECK-NEXT:         .long   .Ltmp3@IMGREL+1
 ; CHECK-NEXT:         .long   "?dtor$[[finbb:[0-9]+]]@?0?main@4HA"@IMGREL
 ; CHECK-NEXT:         .long   0
 ; CHECK-NEXT:         .long   .Ltmp2@IMGREL+1
 ; CHECK-NEXT:         .long   .Ltmp3@IMGREL+1
 ; CHECK-NEXT:         .long   "?filt$0@0@main@@"@IMGREL
-; CHECK-NEXT:         .long   .LBB1_5@IMGREL
+; CHECK-NEXT:         .long   .LBB1_3@IMGREL
 ; CHECK-NEXT:         .long   .Ltmp6@IMGREL+1
 ; CHECK-NEXT:         .long   .Ltmp7@IMGREL+1
 ; CHECK-NEXT:         .long   "?filt$0@0@main@@"@IMGREL
-; CHECK-NEXT:         .long   .LBB1_5@IMGREL
+; CHECK-NEXT:         .long   .LBB1_3@IMGREL
 ; CHECK-NEXT: .Llsda_end0:
 
 ; CHECK:         .text
 ; CHECK:         .seh_endproc
 
-; CHECK: "?dtor$3@?0?main@4HA":
-; CHECK: .seh_proc "?dtor$3@?0?main@4HA"
+; CHECK: "?dtor$[[finbb]]@?0?main@4HA":
+; CHECK: .seh_proc "?dtor$[[finbb]]@?0?main@4HA"
 ; CHECK:         .seh_handler __C_specific_handler, @unwind, @except
 ; CHECK: .LBB1_[[finbb]]:                                # %ehcleanup
 ; CHECK:         movq    %rdx, 16(%rsp)
 ; CHECK:         pushq   %rbp
 ; CHECK:         .seh_pushreg 5
 ; CHECK:         subq    $32, %rsp
 ; CHECK:         .seh_stackalloc 32
 ; CHECK:         leaq    32(%rdx), %rbp

llvm/trunk/test/CodeGen/X86/seh-except-finally.ll

invoke.cont:                                      ; preds = %entry
   %0 = call i8* @llvm.localaddress()
   invoke void @"\01?fin$0@0@use_both@@"(i1 zeroext false, i8* %0) #5
           to label %invoke.cont2 unwind label %catch.dispatch
 
 invoke.cont2:                                     ; preds = %invoke.cont
   br label %__try.cont
 
 __finally:                                             ; preds = %entry
-  %cleanuppad = cleanuppad []
+  %cleanuppad = cleanuppad within none []
   %locals = call i8* @llvm.localaddress()
   invoke void @"\01?fin$0@0@use_both@@"(i1 zeroext true, i8* %locals) #5
-          to label %invoke.cont3 unwind label %cleanupendpad
+          to label %invoke.cont3 unwind label %catch.dispatch
 
 invoke.cont3:                                     ; preds = %__finally
-  cleanupret %cleanuppad unwind label %catch.dispatch
-
-cleanupendpad:
-  cleanupendpad %cleanuppad unwind label %catch.dispatch
+  cleanupret from %cleanuppad unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %invoke.cont3, %lpad1
-  %catchpad = catchpad [i8* bitcast (i32 (i8*, i8*)* @"\01?filt$0@0@use_both@@" to i8*)]
-          to label %__except unwind label %catchendpad
+  %cs1 = catchswitch within none [label %__except] unwind to caller
 
 __except:                                         ; preds = %catch.dispatch
+  %catchpad = catchpad within %cs1 [i8* bitcast (i32 (i8*, i8*)* @"\01?filt$0@0@use_both@@" to i8*)]
   %call = call i32 @puts(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @"\01??_C@_08MLCMLGHM@__except?$AA@", i32 0, i32 0))
-  catchret %catchpad to label %__try.cont
-
-catchendpad:
-  catchendpad unwind to caller
+  catchret from %catchpad to label %__try.cont
 
 __try.cont:                                       ; preds = %__except, %invoke.cont2
   ret void
-
-eh.resume:                                        ; preds = %catch.dispatch
-  %exn = load i8*, i8** %exn.slot
-  %sel4 = load i32, i32* %ehselector.slot
-  %lpad.val = insertvalue { i8*, i32 } undef, i8* %exn, 0
-  %lpad.val5 = insertvalue { i8*, i32 } %lpad.val, i32 %sel4, 1
-  resume { i8*, i32 } %lpad.val5
 }
 
 ; CHECK-LABEL: use_both:
 ; CHECK: .Ltmp0
 ; CHECK: callq crash
 ; CHECK: .Ltmp1
 ; CHECK: .Ltmp4
 ; CHECK: callq "?fin$0@0@use_both@@"

llvm/trunk/test/CodeGen/X86/seh-exception-code.ll

 ; RUN: llc -verify-machineinstrs < %s | FileCheck %s
 ; RUN: llc -verify-machineinstrs -O0 < %s | FileCheck %s
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
 declare void @f(i32)
 declare i32 @__C_specific_handler(...)
 declare i32 @llvm.eh.exceptioncode(token)
 
 define void @ehcode() personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
 entry:
   invoke void @f(i32 0)
           to label %__try.cont unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %pad = catchpad [i8* null]
-          to label %__except unwind label %catchendblock
+  %cs = catchswitch within none [label %__except] unwind to caller
 
 __except:                                         ; preds = %catch.dispatch
-  catchret %pad to label %__except.1
+  %pad = catchpad within %cs [i8* null]
+  catchret from %pad to label %__except.1
 
 __except.1:                                       ; preds = %__except
   %code = call i32 @llvm.eh.exceptioncode(token %pad)
   call void @f(i32 %code)
   br label %__try.cont
 
 __try.cont:                                       ; preds = %entry, %__except.1
   ret void
-
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind to caller
 }
 
 ; CHECK-LABEL: ehcode:
 ; CHECK: xorl %ecx, %ecx
 ; CHECK: callq f
 
-; CHECK: # %catch.dispatch
+; CHECK: # %__except
 ; CHECK: movl %eax, %ecx
 ; CHECK-NEXT: callq f

llvm/trunk/test/CodeGen/X86/seh-finally.ll

invoke void @crash()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   %call = call i32 @puts(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @str_recovered, i64 0, i64 0))
   call void @abort()
   ret i32 0
 
 lpad:                                             ; preds = %entry
-  %p = cleanuppad []
-  %call2 = invoke i32 @puts(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @str_recovered, i64 0, i64 0))
-          to label %invoke.cont1 unwind label %endpad
-
-invoke.cont1:                                     ; preds = %lpad
-  cleanupret %p unwind to caller
-
-endpad:                                   ; preds = %lpad
-  cleanupendpad %p unwind to caller
+  %p = cleanuppad within none []
+  %call2 = call i32 @puts(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @str_recovered, i64 0, i64 0))
+  cleanupret from %p unwind to caller
 }
 
 ; X64-LABEL: main:
 ; X64: retq
 
 ; X64: .seh_handlerdata
 ; X64-NEXT: .long   (.Llsda_end0-.Llsda_begin0)/16
 ; X64-NEXT: .Llsda_begin0:

llvm/trunk/test/CodeGen/X86/seh-safe-div-win32.ll

 define i32 @safe_div(i32* %n, i32* %d) personality i8* bitcast (i32 (...)* @_except_handler3 to i8*) {
 entry:
   %r = alloca i32, align 4
   store i32 42, i32* %r
   invoke void @try_body(i32* %r, i32* %n, i32* %d)
           to label %__try.cont unwind label %lpad0
 
 lpad0:
-  %p0 = catchpad [i8* bitcast (i32 ()* @safe_div_filt0 to i8*)]
-          to label %handler0 unwind label %endpad0
+  %cs0 = catchswitch within none [label %handler0] unwind label %lpad1
 
 handler0:
+  %p0 = catchpad within %cs0 [i8* bitcast (i32 ()* @safe_div_filt0 to i8*)]
   call void @puts(i8* getelementptr ([27 x i8], [27 x i8]* @str1, i32 0, i32 0))
   store i32 -1, i32* %r, align 4
-  catchret %p0 to label %__try.cont
-
-endpad0:
-  catchendpad unwind label %lpad1
+  catchret from %p0 to label %__try.cont
 
 lpad1:
-  %p1 = catchpad [i8* bitcast (i32 ()* @safe_div_filt1 to i8*)]
-          to label %handler1 unwind label %endpad1
+  %cs1 = catchswitch within none [label %handler1] unwind to caller
 
 handler1:
+  %p1 = catchpad within %cs1 [i8* bitcast (i32 ()* @safe_div_filt1 to i8*)]
   call void @puts(i8* getelementptr ([29 x i8], [29 x i8]* @str2, i32 0, i32 0))
   store i32 -2, i32* %r, align 4
-  catchret %p1 to label %__try.cont
-
-endpad1:
-  catchendpad unwind to caller
+  catchret from %p1 to label %__try.cont
 
 __try.cont:
   %safe_ret = load i32, i32* %r, align 4
   ret i32 %safe_ret
 }
 
 ; Normal path code
 
 ; CHECK: {{^}}_safe_div:
 ; CHECK: movl $42, [[rloc:.*\(%ebp\)]]
 ; CHECK: leal [[rloc]],
 ; CHECK: calll _try_body
 ; CHECK: [[cont_bb:LBB0_[0-9]+]]:
 ; CHECK: movl [[rloc]], %eax
 ; CHECK: retl
 
 ; Landing pad code
 
-; CHECK: [[lpad0:LBB0_[0-9]+]]: # %lpad0
+; CHECK: [[handler0:LBB0_[0-9]+]]: # %handler0
 ;   Restore SP
 ; CHECK: movl {{.*}}(%ebp), %esp
 ; CHECK: calll _puts
 ; CHECK: jmp [[cont_bb]]
 
-; CHECK: [[lpad1:LBB0_[0-9]+]]: # %lpad1
+; CHECK: [[handler1:LBB0_[0-9]+]]: # %handler1
 ;   Restore SP
 ; CHECK: movl {{.*}}(%ebp), %esp
 ; CHECK: calll _puts
 ; CHECK: jmp [[cont_bb]]
 
 ; CHECK: .section .xdata,"dr"
 ; CHECK: L__ehtable$safe_div:
 ; CHECK-NEXT: .long -1
 ; CHECK-NEXT: .long _safe_div_filt1
-; CHECK-NEXT: .long [[lpad1]]
+; CHECK-NEXT: .long [[handler1]]
 ; CHECK-NEXT: .long 0
 ; CHECK-NEXT: .long _safe_div_filt0
-; CHECK-NEXT: .long [[lpad0]]
+; CHECK-NEXT: .long [[handler0]]
 
 define void @try_body(i32* %r, i32* %n, i32* %d) {
 entry:
   %0 = load i32, i32* %n, align 4
   %1 = load i32, i32* %d, align 4
   %div = sdiv i32 %0, %1
   store i32 %div, i32* %r, align 4
   ret void

llvm/trunk/test/CodeGen/X86/seh-safe-div.ll

 
 define i32 @safe_div(i32* %n, i32* %d) personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
 entry:
   %r = alloca i32, align 4
   invoke void @try_body(i32* %r, i32* %n, i32* %d)
           to label %__try.cont unwind label %lpad0
 
 lpad0:
-  %p0 = catchpad [i8* bitcast (i32 (i8*, i8*)* @safe_div_filt0 to i8*)]
-          to label %handler0 unwind label %endpad0
+  %cs0 = catchswitch within none [label %handler0] unwind label %lpad1
 
 handler0:
+  %p0 = catchpad within %cs0 [i8* bitcast (i32 (i8*, i8*)* @safe_div_filt0 to i8*)]
   call void @puts(i8* getelementptr ([27 x i8], [27 x i8]* @str1, i32 0, i32 0))
   store i32 -1, i32* %r, align 4
-  catchret %p0 to label %__try.cont
-
-endpad0:
-  catchendpad unwind label %lpad1
+  catchret from %p0 to label %__try.cont
 
 lpad1:
-  %p1 = catchpad [i8* bitcast (i32 (i8*, i8*)* @safe_div_filt1 to i8*)]
-          to label %handler1 unwind label %endpad1
+  %cs1 = catchswitch within none [label %handler1] unwind to caller
 
 handler1:
+  %p1 = catchpad within %cs1 [i8* bitcast (i32 (i8*, i8*)* @safe_div_filt1 to i8*)]
   call void @puts(i8* getelementptr ([29 x i8], [29 x i8]* @str2, i32 0, i32 0))
   store i32 -2, i32* %r, align 4
-  catchret %p1 to label %__try.cont
-
-endpad1:
-  catchendpad unwind to caller
+  catchret from %p1 to label %__try.cont
 
 __try.cont:
   %safe_ret = load i32, i32* %r, align 4
   ret i32 %safe_ret
 }
 
 ; Normal path code
 
 ; CHECK: {{^}}safe_div:
 ; CHECK: .seh_proc safe_div
 ; CHECK: .seh_handler __C_specific_handler, @unwind, @except
 ; CHECK: .Ltmp0:
 ; CHECK: leaq [[rloc:.*\(%rbp\)]], %rcx
 ; CHECK: callq try_body
 ; CHECK-NEXT: .Ltmp1
 ; CHECK: [[cont_bb:\.LBB0_[0-9]+]]:
 ; CHECK: movl [[rloc]], %eax
 ; CHECK: retq
 
 ; Landing pad code
 
-; CHECK: [[lpad0:\.LBB0_[0-9]+]]: # %lpad0
+; CHECK: [[handler0:\.LBB0_[0-9]+]]: # %handler0
 ; CHECK: callq puts
 ; CHECK: movl $-1, [[rloc]]
 ; CHECK: jmp [[cont_bb]]
 
-; CHECK: [[lpad1:\.LBB0_[0-9]+]]: # %lpad1
+; CHECK: [[handler1:\.LBB0_[0-9]+]]: # %handler1
 ; CHECK: callq puts
 ; CHECK: movl $-2, [[rloc]]
 ; CHECK: jmp [[cont_bb]]
 
 ; CHECK: .seh_handlerdata
 ; CHECK-NEXT: .long (.Llsda_end0-.Llsda_begin0)/16
 ; CHECK-NEXT: .Llsda_begin0:
 ; CHECK-NEXT: .long .Ltmp0@IMGREL+1
 ; CHECK-NEXT: .long .Ltmp1@IMGREL+1
 ; CHECK-NEXT: .long safe_div_filt0@IMGREL
-; CHECK-NEXT: .long [[lpad0]]@IMGREL
+; CHECK-NEXT: .long [[handler0]]@IMGREL
 ; CHECK-NEXT: .long .Ltmp0@IMGREL+1
 ; CHECK-NEXT: .long .Ltmp1@IMGREL+1
 ; CHECK-NEXT: .long safe_div_filt1@IMGREL
-; CHECK-NEXT: .long [[lpad1]]@IMGREL
+; CHECK-NEXT: .long [[handler1]]@IMGREL
 ; CHECK-NEXT: .Llsda_end0:
 ; CHECK: .text
 ; CHECK: .seh_endproc
 
 define void @try_body(i32* %r, i32* %n, i32* %d) {
 entry:
   %0 = load i32, i32* %n, align 4
   %1 = load i32, i32* %d, align 4

llvm/trunk/test/CodeGen/X86/seh-stack-realign.ll

 entry:
   ; The EH code allocation is overaligned, triggering realignment.
   %__exceptioncode = alloca i32, align 8
   call void (...) @llvm.localescape(i32* %__exceptioncode)
   invoke void @crash() #5
           to label %__try.cont unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %p = catchpad [i8* bitcast (i32 ()* @"filt$main" to i8*)]
-          to label %__except unwind label %endpad
+  %cs1 = catchswitch within none [label %__except] unwind to caller
 
 __except:                                         ; preds = %lpad
+  %p = catchpad within %cs1 [i8* bitcast (i32 ()* @"filt$main" to i8*)]
   %code = load i32, i32* %__exceptioncode, align 4
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @str, i32 0, i32 0), i32 %code) #4
-  catchret %p to label %__try.cont
-
-endpad:
-  catchendpad unwind to caller
+  catchret from %p to label %__try.cont
 
 __try.cont:                                       ; preds = %entry, %__except
   ret i32 0
 }
 
 define internal i32 @"filt$main"() {
 entry:
   %ebp = tail call i8* @llvm.frameaddress(i32 1)

 ; CHECK-LABEL: _main:
 ; CHECK: Lmain$frame_escape_0 = [[code_offs:[-0-9]+]]
 ; CHECK: movl %esp, [[reg_offs:[-0-9]+]](%esi)
 ; CHECK: movl $L__ehtable$main,
 ;       EH state 0
 ; CHECK: movl $0, 40(%esi)
 ; CHECK: calll _crash
 ; CHECK: retl
-; CHECK: LBB0_[[lpbb:[0-9]+]]: # %lpad
+; CHECK: LBB0_[[lpbb:[0-9]+]]: # %__except
 ;       Restore ESP
 ; CHECK: movl -24(%ebp), %esp
 ;       Restore ESI
 ; CHECK: leal -44(%ebp), %esi
 ;       Restore EBP
 ; CHECK: movl 12(%esi), %ebp
 ; CHECK: movl [[code_offs]](%esi), %[[code:[a-z]+]]
 ; CHECK-DAG: movl %[[code]], 4(%esp)

llvm/trunk/test/CodeGen/X86/tail-dup-catchret.ll

 ; RUN: llc < %s | FileCheck %s
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-pc-windows-msvc18.0.0"
 
 define void @f() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   invoke void @g()
           to label %try.cont unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %0 = catchpad [i8* null, i32 64, i8* null]
-          to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:                                            ; preds = %catch.dispatch
-  catchret %0 to label %try.cont
+  %0 = catchpad within %cs1 [i8* null, i32 64, i8* null]
+  catchret from %0 to label %try.cont
 
 try.cont:                                         ; preds = %entry, %catch
   %b.0 = phi i1 [ false, %catch ], [ true, %entry ]
   tail call void @h(i1 zeroext %b.0)
   ret void
-
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind to caller
 }
 
 ; CHECK-LABEL: _f:
 ; CHECK: calll _g
 ; CHECK: calll _h
 
 declare void @g()
 
 declare i32 @__CxxFrameHandler3(...)
 
 declare void @h(i1 zeroext)

llvm/trunk/test/CodeGen/X86/tail-merge-wineh.ll

entry:
   %tmp1 = alloca i32, align 4
   store i32 0, i32* %i, align 4
   store i32 42, i32* %tmp, align 4
   %0 = bitcast i32* %tmp to i8*
   invoke void @_CxxThrowException(i8* %0, %eh.ThrowInfo* @_TI1H) #1
           to label %unreachable unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %1 = catchpad [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
-          to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind label %catch.dispatch.7
 
 catch:                                            ; preds = %catch.dispatch
-  catchret %1 to label %catchret.dest
+  %1 = catchpad within %cs1 [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
+  catchret from %1 to label %catchret.dest
 
 catchret.dest:                                    ; preds = %catch
   br label %try.cont
 
 try.cont:                                         ; preds = %catchret.dest
   store i32 42, i32* %tmp1, align 4
   %2 = bitcast i32* %tmp1 to i8*
   invoke void @_CxxThrowException(i8* %2, %eh.ThrowInfo* @_TI1H) #1
           to label %unreachable unwind label %catch.dispatch.2
 
 catch.dispatch.2:                                 ; preds = %try.cont
-  %3 = catchpad [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
-          to label %catch.4 unwind label %catchendblock.3
+  %cs2 = catchswitch within none [label %catch.4] unwind label %catch.dispatch.7
 
 catch.4:                                          ; preds = %catch.dispatch.2
-  catchret %3 to label %catchret.dest.5
+  %3 = catchpad within %cs2 [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
+  catchret from %3 to label %catchret.dest.5
 
 catchret.dest.5:                                  ; preds = %catch.4
   br label %try.cont.6
 
 try.cont.6:                                       ; preds = %catchret.dest.5
   br label %try.cont.11
 
-catchendblock.3:                                  ; preds = %catch.dispatch.2
-  catchendpad unwind label %catch.dispatch.7
-
-catch.dispatch.7:                                 ; preds = %catchendblock.3, %catchendblock
-  %4 = catchpad [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
-          to label %catch.9 unwind label %catchendblock.8
+catch.dispatch.7:
+  %cs3 = catchswitch within none [label %catch.9] unwind to caller
 
 catch.9:                                          ; preds = %catch.dispatch.7
-  catchret %4 to label %catchret.dest.10
+  %4 = catchpad within %cs3 [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
+  catchret from %4 to label %catchret.dest.10
 
 catchret.dest.10:                                 ; preds = %catch.9
   br label %try.cont.11
 
 try.cont.11:                                      ; preds = %catchret.dest.10, %try.cont.6
   ret void
 
-catchendblock.8:                                  ; preds = %catch.dispatch.7
-  catchendpad unwind to caller
-
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind label %catch.dispatch.7
-
 unreachable:                                      ; preds = %try.cont, %entry
   unreachable
 }
 
 declare x86_stdcallcc void @_CxxThrowException(i8*, %eh.ThrowInfo*)
 
 declare i32 @__CxxFrameHandler3(...)
 
 attributes #0 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 attributes #1 = { noreturn }

llvm/trunk/test/CodeGen/X86/win-catchpad-csrs.ll

 @"\01??_7type_info@@6B@" = external constant i8*
 @"\01??_R0H@8" = linkonce_odr global %rtti.TypeDescriptor2 { i8** @"\01??_7type_info@@6B@", i8* null, [3 x i8] c".H\00" }, comdat
 
 declare i32 @getint()
 declare void @useints(...)
 declare void @f(i32 %p)
 declare i32 @__CxxFrameHandler3(...)
 
-define i32 @try_catch_catch() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
+define i32 @try_catch_catch() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   %a = call i32 @getint()
   %b = call i32 @getint()
   %c = call i32 @getint()
   %d = call i32 @getint()
   call void (...) @useints(i32 %a, i32 %b, i32 %c, i32 %d)
   invoke void @f(i32 1)
           to label %try.cont unwind label %catch.dispatch
 
-catch.dispatch:                                   ; preds = %entry
-  %0 = catchpad [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
-          to label %catch unwind label %catchendblock
-
-catch:
-  invoke void @f(i32 2)
-          to label %invoke.cont.2 unwind label %catchendblock
-
-invoke.cont.2:                                    ; preds = %catch
-  catchret %0 to label %try.cont
-
-try.cont:                                         ; preds = %entry, %invoke.cont.2, %invoke.cont.3
+try.cont:
   ret i32 0
 
-catchendblock:                                    ; preds = %catch,
-  catchendpad unwind to caller
+catch.dispatch:
+  %cs = catchswitch within none [label %handler1] unwind to caller
+
+handler1:
+  %h1 = catchpad within %cs [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
+  call void @f(i32 2)
+  catchret from %h1 to label %try.cont
 }
 
 ; X86-LABEL: _try_catch_catch:
 ; X86: pushl %ebp
 ; X86: movl %esp, %ebp
 ; X86: pushl %ebx
 ; X86: pushl %edi
 ; X86: pushl %esi

 ; X86: popl %ebp
 ; X86: retl
 
 ; X86: [[restorebb:LBB0_[0-9]+]]:
 ; X86: addl $12, %ebp
 ; X86: jmp [[contbb]]
 
 ; X86: "?catch$[[catch1bb:[0-9]+]]@?0?try_catch_catch@4HA":
-; X86: LBB0_[[catch1bb]]: # %catch.dispatch{{$}}
+; X86: LBB0_[[catch1bb]]: # %handler1{{$}}
 ; X86: pushl %ebp
 ; X86-NOT: pushl
 ; X86: subl $16, %esp
 ; X86: addl $12, %ebp
 ; X86: movl $1, -{{[0-9]+}}(%ebp)
 ; X86: movl $2, (%esp)
 ; X86: calll _f
 ; X86: movl $[[restorebb]], %eax

 ; X64: callq f
 ; X64: [[contbb:\.LBB0_[0-9]+]]: # Block address taken
 ; X64-NEXT:                      # %try.cont
 ; X64: addq $40, %rsp
 ; X64: popq %rbp
 ; X64: retq
 
 ; X64: "?catch$[[catch1bb:[0-9]+]]@?0?try_catch_catch@4HA":
-; X64: LBB0_[[catch1bb]]: # %catch.dispatch{{$}}
+; X64: LBB0_[[catch1bb]]: # %handler1{{$}}
 ; X64: movq %rdx, 16(%rsp)
 ; X64: pushq %rbp
 ; X64: .seh_pushreg 5
 ; X64: pushq %rsi
 ; X64: .seh_pushreg 6
 ; X64: pushq %rdi
 ; X64: .seh_pushreg 7
 ; X64: pushq %rbx

 define i32 @try_one_csr() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   %a = call i32 @getint()
   %b = call i32 @getint()
   call void (...) @useints(i32 %a)
   invoke void @f(i32 1)
           to label %try.cont unwind label %catch.dispatch
 
-catch.dispatch:                                   ; preds = %entry
-  %0 = catchpad [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
-          to label %catch unwind label %catchendblock
+catch.dispatch:
+  %cs = catchswitch within none [label %handler1] unwind to caller
 
-catch:
-  catchret %0 to label %try.cont
+handler1:
+  %0 = catchpad within %cs [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
+  catchret from %0 to label %try.cont
 
-try.cont:                                         ; preds = %entry, %invoke.cont.2, %invoke.cont.3
+try.cont:
   ret i32 0
-
-catchendblock:                                    ; preds = %catch,
-  catchendpad unwind to caller
 }
 
 ; X64-LABEL: try_one_csr:
 ; X64: pushq %rbp
 ; X64: .seh_pushreg 5
 ; X64: pushq %rsi
 ; X64: .seh_pushreg 6
 ; X64-NOT: pushq

 ; X64-NEXT:                      # %try.cont
 ; X64: addq $40, %rsp
 ; X64-NOT: popq
 ; X64: popq %rsi
 ; X64: popq %rbp
 ; X64: retq
 
 ; X64: "?catch$[[catch1bb:[0-9]+]]@?0?try_one_csr@4HA":
-; X64: LBB1_[[catch1bb]]: # %catch.dispatch{{$}}
+; X64: LBB1_[[catch1bb]]: # %handler1{{$}}
 ; X64: movq %rdx, 16(%rsp)
 ; X64: pushq %rbp
 ; X64: .seh_pushreg 5
 ; X64: pushq %rsi
 ; X64: .seh_pushreg 6
 ; X64: subq $40, %rsp
 ; X64: .seh_stackalloc 40
 ; X64: leaq 32(%rdx), %rbp

 ; X64:   .long   "?catch$[[catch1bb]]@?0?try_one_csr@4HA"@IMGREL
 ; X64:   .long   72
 
 define i32 @try_no_csr() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   invoke void @f(i32 1)
           to label %try.cont unwind label %catch.dispatch
 
-catch.dispatch:                                   ; preds = %entry
-  %0 = catchpad [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
-          to label %catch unwind label %catchendblock
+catch.dispatch:
+  %cs = catchswitch within none [label %handler1] unwind to caller
 
-catch:
-  catchret %0 to label %try.cont
+handler1:
+  %cp1 = catchpad within %cs [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
+  catchret from %cp1 to label %try.cont
 
-try.cont:                                         ; preds = %entry, %invoke.cont.2, %invoke.cont.3
+try.cont:
   ret i32 0
-
-catchendblock:                                    ; preds = %catch,
-  catchendpad unwind to caller
 }
 
 ; X64-LABEL: try_no_csr:
 ; X64: pushq %rbp
 ; X64: .seh_pushreg 5
 ; X64-NOT: pushq
 ; X64: subq $48, %rsp
 ; X64: .seh_stackalloc 48
 ; X64: leaq 48(%rsp), %rbp
 ; X64: .seh_setframe 5, 48
 ; X64: .seh_endprologue
 ; X64: movl $1, %ecx
 ; X64: callq f
 ; X64: [[contbb:\.LBB2_[0-9]+]]: # Block address taken
 ; X64-NEXT:                      # %try.cont
 ; X64: addq $48, %rsp
 ; X64-NOT: popq
 ; X64: popq %rbp
 ; X64: retq
 
 ; X64: "?catch$[[catch1bb:[0-9]+]]@?0?try_no_csr@4HA":
-; X64: LBB2_[[catch1bb]]: # %catch.dispatch{{$}}
+; X64: LBB2_[[catch1bb]]: # %handler1{{$}}
 ; X64: movq %rdx, 16(%rsp)
 ; X64: pushq %rbp
 ; X64: .seh_pushreg 5
 ; X64: subq $32, %rsp
 ; X64: .seh_stackalloc 32
 ; X64: leaq 48(%rdx), %rbp
 ; X64: .seh_endprologue
 ; X64: leaq [[contbb]](%rip), %rax

llvm/trunk/test/CodeGen/X86/win-catchpad-nested-cxx.ll

+; RUN: llc -verify-machineinstrs -mtriple=i686-pc-windows-msvc < %s \
+; RUN:     | FileCheck --check-prefix=CHECK --check-prefix=X86 %s
+; RUN: llc -verify-machineinstrs -mtriple=x86_64-pc-windows-msvc < %s \
+; RUN:     | FileCheck --check-prefix=CHECK --check-prefix=X64 %s
+
+; Loosely based on IR for this C++ source code:
+;   void f(int p);
+;   void try_in_catch() {
+;     try {
+;       f(1);
+;     } catch (...) {
+;       try {
+;         f(2);
+;       } catch (...) {
+;         f(3);
+;       }
+;     }
+;   }
+
+declare void @f(i32 %p)
+declare i32 @__CxxFrameHandler3(...)
+
+define i32 @try_in_catch() personality i32 (...)* @__CxxFrameHandler3 {
+entry:
+  invoke void @f(i32 1)
+          to label %try.cont unwind label %catch.dispatch.1
+try.cont:
+  ret i32 0
+
+catch.dispatch.1:
+  %cs1 = catchswitch within none [label %handler1] unwind to caller
+handler1:
+  %h1 = catchpad within %cs1 [i8* null, i32 64, i8* null]
+  invoke void @f(i32 2)
+          to label %catchret1 unwind label %catch.dispatch.2
+catchret1:
+  catchret from %h1 to label %try.cont
+
+catch.dispatch.2:
+  %cs2 = catchswitch within %h1 [label %handler2] unwind to caller
+handler2:
+  %h2 = catchpad within %cs2 [i8* null, i32 64, i8* null]
+  call void @f(i32 3)
+  catchret from %h2 to label %catchret1
+}
+
+; X86-LABEL: L__ehtable$try_in_catch:
+; X64-LABEL: $cppxdata$try_in_catch:
+; CHECK-NEXT: .long   429065506
+; CHECK-NEXT: .long   4
+; CHECK-NEXT: .long   ($stateUnwindMap$try_in_catch)
+; CHECK-NEXT: .long   2
+; CHECK-NEXT: .long   ($tryMap$try_in_catch)
+; ip2state num + ptr
+; X86-NEXT: .long   0
+; X86-NEXT: .long   0
+; X64-NEXT: .long   7
+; X64-NEXT: .long   ($ip2state$try_in_catch)
+; unwindhelp offset
+; X64-NEXT: .long   40
+; CHECK-NEXT: .long   0
+; EHFlags
+; CHECK-NEXT: .long   1
+
+; CHECK: $tryMap$try_in_catch:
+; CHECK-NEXT: .long   2
+; CHECK-NEXT: .long   2
+; CHECK-NEXT: .long   3
+; CHECK-NEXT: .long   1
+; CHECK-NEXT: .long   ($handlerMap$0$try_in_catch)
+; CHECK-NEXT: .long   0
+; CHECK-NEXT: .long   0
+; CHECK-NEXT: .long   3
+; CHECK-NEXT: .long   1
+; CHECK-NEXT: .long   ($handlerMap$1$try_in_catch)
+
+; CHECK: $handlerMap$0$try_in_catch:
+; CHECK-NEXT:   .long   64
+; CHECK-NEXT:   .long   0
+; CHECK-NEXT:   .long   0
+; CHECK-NEXT:   .long   "?catch${{[0-9]+}}@?0?try_in_catch@4HA"
+; X64-NEXT:   .long   56
+
+; CHECK: $handlerMap$1$try_in_catch:
+; CHECK-NEXT:   .long   64
+; CHECK-NEXT:   .long   0
+; CHECK-NEXT:   .long   0
+; CHECK-NEXT:   .long   "?catch${{[0-9]+}}@?0?try_in_catch@4HA"
+; X64-NEXT:   .long   56
+
+; X64: $ip2state$try_in_catch:
+; X64-NEXT: .long   .Lfunc_begin0@IMGREL
+; X64-NEXT: .long   -1
+; X64-NEXT: .long   .Ltmp0@IMGREL+1
+; X64-NEXT: .long   0
+; X64-NEXT: .long   .Ltmp1@IMGREL+1
+; X64-NEXT: .long   -1
+; X64-NEXT: .long   "?catch$2@?0?try_in_catch@4HA"@IMGREL
+; X64-NEXT: .long   1
+; X64-NEXT: .long   .Ltmp2@IMGREL+1
+; X64-NEXT: .long   2
+; X64-NEXT: .long   .Ltmp3@IMGREL+1
+; X64-NEXT: .long   1
+; X64-NEXT: .long   "?catch$4@?0?try_in_catch@4HA"@IMGREL
+; X64-NEXT: .long   3

llvm/trunk/test/CodeGen/X86/win-catchpad-nested.ll

 ; RUN: llc -mtriple=x86_64-pc-windows-coreclr < %s | FileCheck %s
 
 declare void @ProcessCLRException()
 
 declare void @f()
 
 define void @test1() personality void ()* @ProcessCLRException {
 entry:
   invoke void @f()
-          to label %exit unwind label %outer.pad
-outer.pad:
-  %outer = catchpad [i32 1]
-          to label %outer.catch unwind label %outer.end
+          to label %exit unwind label %catch.dispatch.1
+exit:
+  ret void
+
+catch.dispatch.1:
+  %cs1 = catchswitch within none [label %outer.catch] unwind to caller
+
 outer.catch:
+  %cp1 = catchpad within %cs1 [i32 1]
   invoke void @f()
-          to label %outer.ret unwind label %inner.pad
-inner.pad:
-  %inner = catchpad [i32 2]
-          to label %inner.ret unwind label %inner.end
-inner.ret:
-  catchret %inner to label %outer.ret
-inner.end:
-  catchendpad unwind label %outer.end
+          to label %outer.ret unwind label %catch.dispatch.2
 outer.ret:
-  catchret %outer to label %exit
-outer.end:
-  catchendpad unwind to caller
-exit:
-  ret void
+  catchret from %cp1 to label %exit
+
+catch.dispatch.2:
+  %cs2 = catchswitch within %cp1 [label %inner.catch] unwind to caller
+inner.catch:
+  %cp2 = catchpad within %cs2 [i32 2]
+  catchret from %cp2 to label %outer.ret
 }
 
 ; Check the catchret targets
 ; CHECK-LABEL: test1: # @test1
 ; CHECK: [[Exit:^[^: ]+]]: # Block address taken
 ; CHECK-NEXT:              # %exit
 ; CHECK: [[OuterRet:^[^: ]+]]: # Block address taken
 ; CHECK-NEXT:                  # %outer.ret
 ; CHECK-NEXT: leaq [[Exit]](%rip), %rax
 ; CHECK:      retq   # CATCHRET
-; CHECK: {{^[^: ]+}}: # %inner.pad
+; CHECK: {{^[^: ]+}}: # %inner.catch
 ; CHECK: .seh_endprolog
 ; CHECK-NEXT: leaq [[OuterRet]](%rip), %rax
 ; CHECK:      retq   # CATCHRET

llvm/trunk/test/CodeGen/X86/win-catchpad-varargs.ll

 ; RUN: llc -mtriple=x86_64-windows-msvc < %s | FileCheck %s --check-prefix=X64
 ; RUN: llc -mtriple=i686-windows-msvc < %s | FileCheck %s --check-prefix=X86
 
 declare void @llvm.va_start(i8*)
 declare void @llvm.va_end(i8*)
 declare i32 @__CxxFrameHandler3(...)
 declare void @g()
 
 define i32 @f(i32 %a, ...) personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   %ap = alloca i8*
   invoke void @g()
           to label %return unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %0 = catchpad [i8* null, i32 64, i8* null]
-          to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:                                            ; preds = %catch.dispatch
+  %0 = catchpad within %cs1 [i8* null, i32 64, i8* null]
   %ap1 = bitcast i8** %ap to i8*
   call void @llvm.va_start(i8* %ap1)
   %argp.cur = load i8*, i8** %ap
   %1 = bitcast i8* %argp.cur to i32*
   %arg2 = load i32, i32* %1
   call void @llvm.va_end(i8* %ap1)
-  catchret %0 to label %return
-
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind to caller
+  catchret from %0 to label %return
 
 return:                                           ; preds = %entry, %catch
   %retval.0 = phi i32 [ %arg2, %catch ], [ -1, %entry ]
   ret i32 %retval.0
 }
 
 ; X64-LABEL: .seh_proc f
 ; X64: pushq %rbp

llvm/trunk/test/CodeGen/X86/win-catchpad.ll

 @"\01??_7type_info@@6B@" = external constant i8*
 @"\01??_R0H@8" = linkonce_odr global %rtti.TypeDescriptor2 { i8** @"\01??_7type_info@@6B@", i8* null, [3 x i8] c".H\00" }, comdat
 
 
 declare void @f(i32 %p, i32* %l)
 declare i1 @getbool()
 declare i32 @__CxxFrameHandler3(...)
 
-define i32 @try_catch_catch() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
+define i32 @try_catch_catch() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   %e.addr = alloca i32
   %local = alloca i32
   invoke void @f(i32 1, i32* %local)
           to label %try.cont unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %0 = catchpad [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i32* %e.addr]
-          to label %catch unwind label %catch.dispatch.2
+  %cs = catchswitch within none [label %handler1, label %handler2] unwind to caller
 
-catch:                                            ; preds = %catch.dispatch
+handler1:
+  %h1 = catchpad within %cs [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i32* %e.addr]
   %e = load i32, i32* %e.addr
-  invoke void @f(i32 %e, i32* %local)
-          to label %invoke.cont.2 unwind label %catchendblock
+  call void @f(i32 %e, i32* %local)
+  catchret from %h1 to label %try.cont
 
-invoke.cont.2:                                    ; preds = %catch
-  catchret %0 to label %try.cont
+handler2:
+  %h2 = catchpad within %cs [i8* null, i32 64, i8* null]
+  call void @f(i32 3, i32* %local)
+  catchret from %h2 to label %try.cont
 
-catch.dispatch.2:                                   ; preds = %catch.dispatch
-  %1 = catchpad [i8* null, i32 u0x40, i8* null]
-          to label %catch.2 unwind label %catchendblock
-
-catch.2:                                            ; preds = %catch.dispatch.2
-  invoke void @f(i32 3, i32* %local)
-          to label %invoke.cont.3 unwind label %catchendblock
-
-invoke.cont.3:                                    ; preds = %catch.2
-  catchret %1 to label %try.cont
-
-try.cont:                                         ; preds = %entry, %invoke.cont.2, %invoke.cont.3
+try.cont:
   ret i32 0
-
-catchendblock:                                    ; preds = %catch, %catch.2, %catch.dispatch.2
-  catchendpad unwind to caller
 }
 
 ; X86-LABEL: _try_catch_catch:
 ; X86: movl %esp, -[[sp_offset:[0-9]+]](%ebp)
 ; X86: movl $0, -{{[0-9]+}}(%ebp)
 ; X86: leal -[[local_offs:[0-9]+]](%ebp), %[[addr_reg:[a-z]+]]
 ; X86-DAG: movl %[[addr_reg]], 4(%esp)
 ; X86-DAG: movl $1, (%esp)
 ; X86: calll _f
 ; X86: [[contbb:LBB0_[0-9]+]]: # %try.cont
 ; X86: retl
 
 ; X86: [[restorebb1:LBB0_[0-9]+]]: # Block address taken
-; X86-NEXT:                        # %invoke.cont.2
+; X86-NEXT:                        # %handler1
 ; X86-NEXT: addl $12, %ebp
 ; X86: jmp [[contbb]]
 
 ; FIXME: These should be de-duplicated.
 ; X86: [[restorebb2:LBB0_[0-9]+]]: # Block address taken
-; X86-NEXT:                        # %invoke.cont.3
+; X86-NEXT:                        # %handler2
 ; X86-NEXT: addl $12, %ebp
 ; X86: jmp [[contbb]]
 
 ; X86: "?catch$[[catch1bb:[0-9]+]]@?0?try_catch_catch@4HA":
-; X86: LBB0_[[catch1bb]]: # %catch.dispatch{{$}}
+; X86: LBB0_[[catch1bb]]: # %handler1{{$}}
 ; X86: pushl %ebp
 ; X86: subl $8, %esp
 ; X86: addl $12, %ebp
 ; X86: movl %esp, -[[sp_offset]](%ebp)
-; X86: leal -[[local_offs]](%ebp), %[[addr_reg:[a-z]+]]
-; X86: movl -32(%ebp), %[[e_reg:[a-z]+]]
-; X86: movl $1, -{{[0-9]+}}(%ebp)
+; X86-DAG: movl -32(%ebp), %[[e_reg:[a-z]+]]
+; X86-DAG: leal -[[local_offs]](%ebp), %[[addr_reg:[a-z]+]]
+; X86-DAG: movl $1, -{{[0-9]+}}(%ebp)
 ; X86-DAG: movl %[[addr_reg]], 4(%esp)
 ; X86-DAG: movl %[[e_reg]], (%esp)
 ; X86: calll _f
 ; X86-NEXT: movl $[[restorebb1]], %eax
 ; X86-NEXT: addl $8, %esp
 ; X86-NEXT: popl %ebp
 ; X86-NEXT: retl
 
 ; X86: "?catch$[[catch2bb:[0-9]+]]@?0?try_catch_catch@4HA":
-; X86: LBB0_[[catch2bb]]: # %catch.dispatch.2{{$}}
+; X86: LBB0_[[catch2bb]]: # %handler2{{$}}
 ; X86: pushl %ebp
 ; X86: subl $8, %esp
 ; X86: addl $12, %ebp
 ; X86: movl %esp, -[[sp_offset]](%ebp)
-; X86: leal -[[local_offs]](%ebp), %[[addr_reg:[a-z]+]]
-; X86: movl $1, -{{[0-9]+}}(%ebp)
+; X86-DAG: leal -[[local_offs]](%ebp), %[[addr_reg:[a-z]+]]
+; X86-DAG: movl $1, -{{[0-9]+}}(%ebp)
 ; X86-DAG: movl %[[addr_reg]], 4(%esp)
 ; X86-DAG: movl $3, (%esp)
 ; X86: calll _f
 ; X86-NEXT: movl $[[restorebb2]], %eax
 ; X86-NEXT: addl $8, %esp
 ; X86-NEXT: popl %ebp
 ; X86-NEXT: retl
 

 ; X64: callq f
 ; X64: [[contbb:\.LBB0_[0-9]+]]: # Block address taken
 ; X64-NEXT:                      # %try.cont
 ; X64: addq $48, %rsp
 ; X64: popq %rbp
 ; X64: retq
 
 ; X64: "?catch$[[catch1bb:[0-9]+]]@?0?try_catch_catch@4HA":
-; X64: LBB0_[[catch1bb]]: # %catch.dispatch{{$}}
+; X64: LBB0_[[catch1bb]]: # %handler1{{$}}
 ; X64: movq %rdx, 16(%rsp)
 ; X64: pushq %rbp
 ; X64: .seh_pushreg 5
 ; X64: subq $32, %rsp
 ; X64: .seh_stackalloc 32
 ; X64: leaq 48(%rdx), %rbp
 ; X64: .seh_endprologue
-; X64-DAG: .Ltmp4
 ; X64-DAG: leaq -[[local_offs]](%rbp), %rdx
 ; X64-DAG: movl -12(%rbp), %ecx
 ; X64: callq f
 ; X64: leaq [[contbb]](%rip), %rax
 ; X64-NEXT: addq $32, %rsp
 ; X64-NEXT: popq %rbp
 ; X64-NEXT: retq
 
 ; X64: "?catch$[[catch2bb:[0-9]+]]@?0?try_catch_catch@4HA":
-; X64: LBB0_[[catch2bb]]: # %catch.dispatch.2{{$}}
+; X64: LBB0_[[catch2bb]]: # %handler2{{$}}
 ; X64: movq %rdx, 16(%rsp)
 ; X64: pushq %rbp
 ; X64: .seh_pushreg 5
 ; X64: subq $32, %rsp
 ; X64: .seh_stackalloc 32
 ; X64: leaq 48(%rdx), %rbp
 ; X64: .seh_endprologue
 ; X64-DAG: leaq -[[local_offs]](%rbp), %rdx
 ; X64-DAG: movl $3, %ecx
 ; X64: callq f
-; X64: .Ltmp3
 ; X64: leaq [[contbb]](%rip), %rax
 ; X64-NEXT: addq $32, %rsp
 ; X64-NEXT: popq %rbp
 ; X64-NEXT: retq
 
 ; X64: $cppxdata$try_catch_catch:
 ; X64-NEXT: .long   429065506
 ; X64-NEXT: .long   2
 ; X64-NEXT: .long   ($stateUnwindMap$try_catch_catch)@IMGREL
 ; X64-NEXT: .long   1
 ; X64-NEXT: .long   ($tryMap$try_catch_catch)@IMGREL
-; X64-NEXT: .long   4
+; X64-NEXT: .long   5
 ; X64-NEXT: .long   ($ip2state$try_catch_catch)@IMGREL
 ; X64-NEXT: .long   40
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   1
 
 ; X64: $tryMap$try_catch_catch:
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0

 ; X64-NEXT:   .long   "?catch$[[catch2bb]]@?0?try_catch_catch@4HA"@IMGREL
 ; X64-NEXT:   .long   56
 
 ; X64: $ip2state$try_catch_catch:
 ; X64-NEXT: .long   .Lfunc_begin0@IMGREL
 ; X64-NEXT: .long   -1
 ; X64-NEXT: .long   .Ltmp0@IMGREL+1
 ; X64-NEXT: .long   0
-; X64-NEXT: .long   .Ltmp4@IMGREL+1
-; X64-NEXT: .long   1
-; X64-NEXT: .long   .Ltmp3@IMGREL+1
+; X64-NEXT: .long   .Ltmp1@IMGREL+1
 ; X64-NEXT: .long   -1
+; X64-NEXT: .long   "?catch$[[catch1bb]]@?0?try_catch_catch@4HA"@IMGREL
+; X64-NEXT: .long   1
+; X64-NEXT: .long   "?catch$[[catch2bb]]@?0?try_catch_catch@4HA"@IMGREL
+; X64-NEXT: .long   1
 
 
-define i32 @branch_to_normal_dest() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
+define i32 @branch_to_normal_dest() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   invoke void @f(i32 1, i32* null)
           to label %try.cont unwind label %catch.dispatch
 
 catch.dispatch:
-  %0 = catchpad [i8* null, i32 64, i8* null]
-          to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:
+  %cp1 = catchpad within %cs1 [i8* null, i32 64, i8* null]
+  br label %loop
+
+loop:
   %V = call i1 @getbool()
-  br i1 %V, label %catch, label %catch.done
+  br i1 %V, label %loop, label %catch.done
 
 catch.done:
-  catchret %0 to label %try.cont
+  catchret from %cp1 to label %try.cont
 
 try.cont:
   ret i32 0
-
-catchendblock:
-  catchendpad unwind to caller
 }
 
 ; X86-LABEL: _branch_to_normal_dest:
 ; X86: calll _f
 
 ; X86: [[contbb:LBB1_[0-9]+]]: # %try.cont
 ; X86: retl
 
 ; X86: [[restorebb:LBB1_[0-9]+]]: # Block address taken
 ; X86-NEXT:                       # %catch.done
 ; X86-NEXT: addl $12, %ebp
 ; X86: jmp [[contbb]]
 
-; X86: "?catch$[[catchdispbb:[0-9]+]]@?0?branch_to_normal_dest@4HA":
-; X86: LBB1_[[catchdispbb]]: # %catch.dispatch{{$}}
+; X86: "?catch$[[catchbb:[0-9]+]]@?0?branch_to_normal_dest@4HA":
+; X86: LBB1_[[catchbb]]: # %catch{{$}}
 ; X86: pushl %ebp
 ; X86: subl $8, %esp
 ; X86: addl $12, %ebp
-
-; X86: LBB1_[[catchbb:[0-9]+]]: # %catch
-; X86: movl    $-1, -16(%ebp)
+; X86: LBB1_[[loopbb:[0-9]+]]: # %loop
+; X86: movl    $1, -16(%ebp)
 ; X86: calll   _getbool
 ; X86: testb   $1, %al
-; X86: jne LBB1_[[catchbb]]
+; X86: jne LBB1_[[loopbb]]
 ; X86: # %catch.done
 ; X86-NEXT: movl $[[restorebb]], %eax
 ; X86-NEXT: addl $8, %esp
 ; X86-NEXT: popl %ebp
 ; X86-NEXT: retl
 
 ; X86: L__ehtable$branch_to_normal_dest:
 ; X86: $handlerMap$0$branch_to_normal_dest:
 ; X86-NEXT:   .long   64
 ; X86-NEXT:   .long   0
 ; X86-NEXT:   .long   0
-; X86-NEXT:   .long   "?catch$[[catchdispbb]]@?0?branch_to_normal_dest@4HA"
+; X86-NEXT:   .long   "?catch$[[catchbb]]@?0?branch_to_normal_dest@4HA"
 
 ; X64-LABEL: branch_to_normal_dest:
 ; X64: # %entry
 ; X64: pushq %rbp
 ; X64: .seh_pushreg 5
 ; X64: subq $48, %rsp
 ; X64: .seh_stackalloc 48
 ; X64: leaq 48(%rsp), %rbp
 ; X64: .seh_setframe 5, 48
 ; X64: .seh_endprologue
 ; X64: .Ltmp[[before_call:[0-9]+]]:
 ; X64: callq f
 ; X64: .Ltmp[[after_call:[0-9]+]]:
 ; X64: [[contbb:\.LBB1_[0-9]+]]: # Block address taken
 ; X64-NEXT:                      # %try.cont
 ; X64: addq $48, %rsp
 ; X64: popq %rbp
 ; X64: retq
 
 ; X64: "?catch$[[catchbb:[0-9]+]]@?0?branch_to_normal_dest@4HA":
-; X64: LBB1_[[catchbb]]: # %catch.dispatch{{$}}
+; X64: LBB1_[[catchbb]]: # %catch{{$}}
 ; X64: movq %rdx, 16(%rsp)
 ; X64: pushq %rbp
 ; X64: .seh_pushreg 5
 ; X64: subq $32, %rsp
 ; X64: .seh_stackalloc 32
 ; X64: leaq 48(%rdx), %rbp
 ; X64: .seh_endprologue
-; X64: .LBB1_[[normal_dest_bb:[0-9]+]]: # %catch
+; X64: .LBB1_[[normal_dest_bb:[0-9]+]]: # %loop
 ; X64: callq   getbool
 ; X64: testb   $1, %al
 ; X64: jne     .LBB1_[[normal_dest_bb]]
 ; X64: # %catch.done
 ; X64: leaq [[contbb]](%rip), %rax
 ; X64-NEXT: addq $32, %rsp
 ; X64-NEXT: popq %rbp
 ; X64-NEXT: retq
 
 ; X64-LABEL: $cppxdata$branch_to_normal_dest:
 ; X64-NEXT: .long   429065506
 ; X64-NEXT: .long   2
 ; X64-NEXT: .long   ($stateUnwindMap$branch_to_normal_dest)@IMGREL
 ; X64-NEXT: .long   1
 ; X64-NEXT: .long   ($tryMap$branch_to_normal_dest)@IMGREL
-; X64-NEXT: .long   3
+; X64-NEXT: .long   4
 ; X64-NEXT: .long   ($ip2state$branch_to_normal_dest)@IMGREL
 ; X64-NEXT: .long   40
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   1
 
 ; X64-LABEL: $stateUnwindMap$branch_to_normal_dest:
 ; X64-NEXT: .long   -1
 ; X64-NEXT: .long   0

 
 ; X64-LABEL: $ip2state$branch_to_normal_dest:
 ; X64-NEXT: .long   .Lfunc_begin1@IMGREL
 ; X64-NEXT: .long   -1
 ; X64-NEXT: .long   .Ltmp[[before_call]]@IMGREL+1
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   .Ltmp[[after_call]]@IMGREL+1
 ; X64-NEXT: .long   -1
+; X64-NEXT: .long   "?catch$[[catchbb]]@?0?branch_to_normal_dest@4HA"@IMGREL
+; X64-NEXT: .long   1

llvm/trunk/test/CodeGen/X86/win-cleanuppad.ll

 ; RUN: llc -verify-machineinstrs -mtriple=i686-pc-windows-msvc < %s | FileCheck --check-prefix=X86 %s
 ; RUN: llc -verify-machineinstrs -mtriple=x86_64-pc-windows-msvc < %s | FileCheck --check-prefix=X64 %s
 
 %struct.Dtor = type { i8 }
 
 define void @simple_cleanup() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %o = alloca %struct.Dtor, align 1
   invoke void @f(i32 1)
           to label %invoke.cont unwind label %ehcleanup
 
 invoke.cont:                                      ; preds = %entry
   call x86_thiscallcc void @"\01??1Dtor@@QAE@XZ"(%struct.Dtor* %o) #2
   ret void
 
 ehcleanup:                                        ; preds = %entry
-  %0 = cleanuppad []
+  %0 = cleanuppad within none []
   call x86_thiscallcc void @"\01??1Dtor@@QAE@XZ"(%struct.Dtor* %o) #2
-  cleanupret %0 unwind to caller
+  cleanupret from %0 unwind to caller
 }
 
 ; CHECK: simple_cleanup:                         # @simple_cleanup
 ; CHECK:         pushq   %rbp
 ; CHECK:         subq    $48, %rsp
 ; CHECK:         leaq    48(%rsp), %rbp
 ; CHECK:         movq    $-2, -8(%rbp)
 ; CHECK:         movl    $1, %ecx
invoke.cont.1:                                    ; preds = %invoke.cont
   invoke void @f(i32 3)
           to label %invoke.cont.2 unwind label %cleanup.outer
 
 invoke.cont.2:                                    ; preds = %invoke.cont.1
   call x86_thiscallcc void @"\01??1Dtor@@QAE@XZ"(%struct.Dtor* %o1) #2
   ret void
 
 cleanup.inner:                                        ; preds = %invoke.cont
-  %0 = cleanuppad []
+  %0 = cleanuppad within none []
   call x86_thiscallcc void @"\01??1Dtor@@QAE@XZ"(%struct.Dtor* %o2) #2
-  cleanupret %0 unwind label %cleanup.outer
+  cleanupret from %0 unwind label %cleanup.outer
 
 cleanup.outer:                                      ; preds = %invoke.cont.1, %cleanup.inner, %entry
-  %1 = cleanuppad []
+  %1 = cleanuppad within none []
   call x86_thiscallcc void @"\01??1Dtor@@QAE@XZ"(%struct.Dtor* %o1) #2
-  cleanupret %1 unwind to caller
+  cleanupret from %1 unwind to caller
 }
 
 ; X86-LABEL: _nested_cleanup:
 ; X86: movl    $1, (%esp)
 ; X86: calll   _f
 ; X86: movl    $2, (%esp)
 ; X86: calll   _f
 ; X86: movl    $3, (%esp)

llvm/trunk/test/CodeGen/X86/win-funclet-cfi.ll

 ; RUN: llc -mtriple=x86_64-windows-msvc < %s | FileCheck %s
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
 define void @"\01?f@@YAXXZ"(i1 %B) personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   invoke void @g()
           to label %unreachable unwind label %cleanupblock
 
 cleanupblock:
-  %cleanp = cleanuppad []
+  %cleanp = cleanuppad within none []
   call void @g()
-  cleanupret %cleanp unwind label %catch.dispatch
+  cleanupret from %cleanp unwind label %catch.dispatch
 
 catch.dispatch:
-  %cp = catchpad [i8* null, i32 64, i8* null]
-          to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:
+  %cp = catchpad within %cs1 [i8* null, i32 64, i8* null]
   call void @g()
-  catchret %cp to label %try.cont
+  catchret from %cp to label %try.cont
 
 try.cont:
   ret void
 
-catchendblock:
-  catchendpad unwind to caller
-
 unreachable:
   unreachable
 }
 
 
 declare void @g()
 
 declare i32 @__CxxFrameHandler3(...)

 ; CHECK: .seh_handlerdata
 ; CHECK-NOT:  .long   ("$cppxdata$?f@@YAXXZ")@IMGREL
 ; CHECK-NEXT: .text
 ; CHECK: .seh_endproc
 
 ; CHECK: "?catch$[[catch:[0-9]+]]@?0??f@@YAXXZ@4HA":
 ; CHECK: .seh_proc "?catch$[[catch]]@?0??f@@YAXXZ@4HA"
 ; CHECK-NEXT: .seh_handler __CxxFrameHandler3, @unwind, @except
-; CHECK: LBB0_[[catch]]: # %catch.dispatch{{$}}
+; CHECK: LBB0_[[catch]]: # %catch{{$}}
 
 ; Emit CFI for pushing RBP.
 ; CHECK: movq    %rdx, 16(%rsp)
 ; CHECK: pushq   %rbp
 ; CHECK: .seh_pushreg 5
 
 ; Emit CFI for allocating from the stack pointer.
 ; CHECK: subq    $32, %rsp

llvm/trunk/test/CodeGen/X86/win-mixed-ehpersonality.ll

 entry:
   invoke void @maybe_throw()
       to label %cont unwind label %lpad
 
 cont:
   ret i32 0
 
 lpad:
-  %p = catchpad [i8* bitcast (i32 (i8*, i8*)* @filt_g to i8*)]
-      to label %catch unwind label %endpad
+  %cs = catchswitch within none [label %catch] unwind to caller
 catch:
-  catchret %p to label %ret1
-endpad:
-  catchendpad unwind to caller
+  %p = catchpad within %cs [i8* bitcast (i32 (i8*, i8*)* @filt_g to i8*)]
+  catchret from %p to label %ret1
 
 ret1:
   ret i32 1
 }
 
 define internal i32 @filt_g(i8*, i8*) {
   %g = load i32, i32* @g
   ret i32 %g
 }
 
 ; CHECK-LABEL: use_seh:
 ; CHECK: callq maybe_throw
 ; CHECK: xorl %eax, %eax
 ; CHECK: .LBB0_[[epilogue:[0-9]+]]
 ; CHECK: retq
-; CHECK: # %lpad
+; CHECK: # %catch{{$}}
 ; CHECK: movl $1, %eax
 ; CHECK: jmp .LBB0_[[epilogue]]
 
 ; A MinGW64-ish EH style. It could happen if a binary uses both MSVC CRT and
 ; mingw CRT and is linked with LTO.
 define i32 @use_gcc() personality i32 (...)* @__gxx_personality_seh0 {
 entry:
   invoke void @maybe_throw()

llvm/trunk/test/CodeGen/X86/win32-eh-states.ll

-; RUN: llc -mtriple=i686-pc-windows-msvc < %s | FileCheck %s
+; RUN: llc -mtriple=i686-pc-windows-msvc   < %s | FileCheck %s --check-prefix=X86
+; RUN: llc -mtriple=x86_64-pc-windows-msvc < %s | FileCheck %s --check-prefix=X64
 
 ; Based on this source:
 ; extern "C" void may_throw(int);
 ; void f() {
 ;   try {
 ;     may_throw(1);
 ;     try {
 ;       may_throw(2);
entry:
   invoke void @may_throw(i32 1)
           to label %invoke.cont unwind label %lpad.1
 
 invoke.cont:                                      ; preds = %entry
   invoke void @may_throw(i32 2)
           to label %try.cont.9 unwind label %lpad
 
 try.cont.9:                                       ; preds = %invoke.cont.3, %invoke.cont, %catch.7
-  ; FIXME: Something about our CFG breaks TailDuplication. This empy asm blocks
-  ; it so we can focus on testing the state numbering.
-  call void asm sideeffect "", "~{dirflag},~{fpsr},~{flags}"()
   ret void
 
 lpad:                                             ; preds = %catch, %entry
-  %p1 = catchpad [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
-      to label %catch unwind label %end.inner.catch
+  %cs1 = catchswitch within none [label %catch] unwind label %lpad.1
 
 catch:                                            ; preds = %lpad.1
+  %p1 = catchpad within %cs1 [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
   invoke void @may_throw(i32 3)
-          to label %invoke.cont.3 unwind label %end.inner.catch
+          to label %invoke.cont.3 unwind label %lpad.1
 
 invoke.cont.3:                                    ; preds = %catch
-  catchret %p1 to label %try.cont.9
-
-
-end.inner.catch:
-  catchendpad unwind label %lpad.1
+  catchret from %p1 to label %try.cont.9
 
 lpad.1:                                           ; preds = %invoke.cont
-  %p2 = catchpad [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
-      to label %catch.7 unwind label %eh.resume
+  %cs2 = catchswitch within none [label %catch.7] unwind to caller
 
 catch.7:
-  invoke void @may_throw(i32 4)
-          to label %invoke.cont.10 unwind label %eh.resume
+  %p2 = catchpad within %cs2 [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null]
+  call void @may_throw(i32 4)
+  catchret from %p2 to label %try.cont.9
+}
+
+; X86-LABEL: _f:
+; X86: movl $-1, [[state:[-0-9]+]](%ebp)
+; X86: movl $___ehhandler$f, {{.*}}
+;
+; X86: movl $0, [[state]](%ebp)
+; X86: movl $1, (%esp)
+; X86: calll _may_throw
+;
+; X86: movl $1, [[state]](%ebp)
+; X86: movl $2, (%esp)
+; X86: calll _may_throw
+;
+; X86: movl $2, [[state]](%ebp)
+; X86: movl $3, (%esp)
+; X86: calll _may_throw
+;
+; X86: movl $3, [[state]](%ebp)
+; X86: movl $4, (%esp)
+; X86: calll _may_throw
+
+
+; X64-LABEL: f:
+; X64-LABEL: $ip2state$f:
+; X64-NEXT:   .long .Lfunc_begin0@IMGREL
+; X64-NEXT:   .long -1
+; X64-NEXT:   .long .Ltmp{{.*}}@IMGREL+1
+; X64-NEXT:   .long 0
+; X64-NEXT:   .long .Ltmp{{.*}}@IMGREL+1
+; X64-NEXT:   .long 1
+; X64-NEXT:   .long .Ltmp{{.*}}@IMGREL+1
+; X64-NEXT:   .long -1
+; X64-NEXT:   .long "?catch${{.*}}@?0?f@4HA"@IMGREL
+; X64-NEXT:   .long 2
+; X64-NEXT:   .long "?catch${{.*}}@?0?f@4HA"@IMGREL
+; X64-NEXT:   .long 3
+
+; Based on this source:
+; extern "C" void may_throw(int);
+; struct S { ~S(); };
+; void g() {
+;   S x;
+;   try {
+;     may_throw(-1);
+;   } catch (...) {
+;     may_throw(0);
+;     {
+;       S y;
+;       may_throw(1);
+;     }
+;     may_throw(2);
+;   }
+; }
 
-invoke.cont.10:
-  catchret %p2 to label %try.cont.9
+%struct.S = type { i8 }
+declare void @"\01??1S@@QEAA@XZ"(%struct.S*)
 
-eh.resume:                                        ; preds = %catch.dispatch.4
-  catchendpad unwind to caller
+define void @g() personality i32 (...)* @__CxxFrameHandler3 {
+entry:
+  %x = alloca %struct.S, align 1
+  %y = alloca %struct.S, align 1
+  invoke void @may_throw(i32 -1)
+          to label %unreachable unwind label %catch.dispatch
+
+catch.dispatch:                                   ; preds = %entry
+  %0 = catchswitch within none [label %catch] unwind label %ehcleanup5
+
+catch:                                            ; preds = %catch.dispatch
+  %1 = catchpad within %0 [i8* null, i32 64, i8* null]
+  invoke void @may_throw(i32 0)
+          to label %invoke.cont unwind label %ehcleanup5
+
+invoke.cont:                                      ; preds = %catch
+  invoke void @may_throw(i32 1)
+          to label %invoke.cont2 unwind label %ehcleanup
+
+invoke.cont2:                                     ; preds = %invoke.cont
+  invoke void @"\01??1S@@QEAA@XZ"(%struct.S* nonnull %y)
+          to label %invoke.cont3 unwind label %ehcleanup5
+
+invoke.cont3:                                     ; preds = %invoke.cont2
+  invoke void @may_throw(i32 2)
+          to label %invoke.cont4 unwind label %ehcleanup5
+
+invoke.cont4:                                     ; preds = %invoke.cont3
+  catchret from %1 to label %try.cont
+
+try.cont:                                         ; preds = %invoke.cont4
+  call void @"\01??1S@@QEAA@XZ"(%struct.S* nonnull %x)
+  ret void
+
+ehcleanup:                                        ; preds = %invoke.cont
+  %2 = cleanuppad within %1 []
+  call void @"\01??1S@@QEAA@XZ"(%struct.S* nonnull %y)
+  cleanupret from %2 unwind label %ehcleanup5
+
+ehcleanup5:                                       ; preds = %invoke.cont2, %invoke.cont3, %ehcleanup, %catch, %catch.dispatch
+  %3 = cleanuppad within none []
+  call void @"\01??1S@@QEAA@XZ"(%struct.S* nonnull %x)
+  cleanupret from %3 unwind to caller
+
+unreachable:                                      ; preds = %entry
+  unreachable
 }
 
-; CHECK-LABEL: _f:
-; CHECK: movl $-1, [[state:[-0-9]+]](%ebp)
-; CHECK: movl $___ehhandler$f, {{.*}}
-;
-; CHECK: movl $0, [[state]](%ebp)
-; CHECK: movl $1, (%esp)
-; CHECK: calll _may_throw
-;
-; CHECK: movl $1, [[state]](%ebp)
-; CHECK: movl $2, (%esp)
-; CHECK: calll _may_throw
-;
-; CHECK: movl $2, [[state]](%ebp)
-; CHECK: movl $3, (%esp)
-; CHECK: calll _may_throw
-;
-; CHECK: movl $3, [[state]](%ebp)
-; CHECK: movl $4, (%esp)
-; CHECK: calll _may_throw
+; X86-LABEL: _g:
+; X86: movl $-1, [[state:[-0-9]+]](%ebp)
+; X86: movl $___ehhandler$g, {{.*}}
+;
+; X86: movl $1, [[state]](%ebp)
+; X86: movl $-1, (%esp)
+; X86: calll _may_throw
+;
+; X86: movl $2, [[state]](%ebp)
+; X86: movl $0, (%esp)
+; X86: calll _may_throw
+;
+; X86: movl $3, [[state]](%ebp)
+; X86: movl $1, (%esp)
+; X86: calll _may_throw
+;
+; X86: movl $2, [[state]](%ebp)
+; X86: movl $2, (%esp)
+; X86: calll _may_throw
+
+; X64-LABEL: g:
+; X64-LABEL: $ip2state$g:
+; X64-NEXT:   .long .Lfunc_begin1@IMGREL
+; X64-NEXT:   .long -1
+; X64-NEXT:   .long .Ltmp{{.*}}@IMGREL+1
+; X64-NEXT:   .long 1
+; X64-NEXT:   .long .Ltmp{{.*}}@IMGREL+1
+; X64-NEXT:   .long -1
+; X64-NEXT:   .long "?catch${{.*}}@?0?g@4HA"@IMGREL
+; X64-NEXT:   .long 2
+; X64-NEXT:   .long .Ltmp{{.*}}@IMGREL+1
+; X64-NEXT:   .long 3
+; X64-NEXT:   .long .Ltmp{{.*}}@IMGREL+1
+; X64-NEXT:   .long 2
+
 
-; CHECK: .safeseh ___ehhandler$f
+; X86: .safeseh ___ehhandler$f
+; X86: .safeseh ___ehhandler$g

llvm/trunk/test/CodeGen/X86/win32-eh.ll

 
 define void @use_except_handler3() personality i32 (...)* @_except_handler3 {
 entry:
   invoke void @may_throw_or_crash()
       to label %cont unwind label %lpad
 cont:
   ret void
 lpad:
-  %p = catchpad [i8* bitcast (i32 ()* @catchall_filt to i8*)]
-      to label %catch unwind label %endpad
+  %cs = catchswitch within none [label %catch] unwind to caller
 catch:
-  catchret %p to label %cont
-endpad:
-  catchendpad unwind to caller
+  %p = catchpad within %cs [i8* bitcast (i32 ()* @catchall_filt to i8*)]
+  catchret from %p to label %cont
 }
 
 ; CHECK-LABEL: _use_except_handler3:
 ; CHECK: pushl %ebp
 ; CHECK: movl %esp, %ebp
 ; CHECK: pushl %ebx
 ; CHECK: pushl %edi
 ; CHECK: pushl %esi
 ; CHECK: subl ${{[0-9]+}}, %esp
 ; CHECK: movl $-1, -16(%ebp)
 ; CHECK: movl $L__ehtable$use_except_handler3, -20(%ebp)
 ; CHECK: leal -28(%ebp), %[[node:[^ ,]*]]
 ; CHECK: movl $__except_handler3, -24(%ebp)
 ; CHECK: movl %fs:0, %[[next:[^ ,]*]]
 ; CHECK: movl %[[next]], -28(%ebp)
 ; CHECK: movl %[[node]], %fs:0
 ; CHECK: calll _may_throw_or_crash
 ; CHECK: movl -28(%ebp), %[[next:[^ ,]*]]
 ; CHECK: movl %[[next]], %fs:0
 ; CHECK: retl
-; CHECK: LBB1_2: # %lpad{{$}}
+; CHECK: LBB1_2: # %catch{{$}}
 
 ; CHECK: .section .xdata,"dr"
 ; CHECK-LABEL: L__ehtable$use_except_handler3:
 ; CHECK-NEXT:  .long   -1
 ; CHECK-NEXT:  .long   _catchall_filt
 ; CHECK-NEXT:  .long   LBB1_2
 
 define void @use_except_handler4() personality i32 (...)* @_except_handler4 {
 entry:
   invoke void @may_throw_or_crash()
       to label %cont unwind label %lpad
 cont:
   ret void
 lpad:
-  %p = catchpad [i8* bitcast (i32 ()* @catchall_filt to i8*)]
-      to label %catch unwind label %endpad
+  %cs = catchswitch within none [label %catch] unwind to caller
 catch:
-  catchret %p to label %cont
-endpad:
-  catchendpad unwind to caller
+  %p = catchpad within %cs [i8* bitcast (i32 ()* @catchall_filt to i8*)]
+  catchret from %p to label %cont
 }
 
 ; CHECK-LABEL: _use_except_handler4:
 ; CHECK: pushl %ebp
 ; CHECK: movl %esp, %ebp
 ; CHECK: subl ${{[0-9]+}}, %esp
 ; CHECK: movl %esp, -36(%ebp)
 ; CHECK: movl $-2, -16(%ebp)
 ; CHECK: movl $L__ehtable$use_except_handler4, %[[lsda:[^ ,]*]]
 ; CHECK: xorl ___security_cookie, %[[lsda]]
 ; CHECK: movl %[[lsda]], -20(%ebp)
 ; CHECK: leal -28(%ebp), %[[node:[^ ,]*]]
 ; CHECK: movl $__except_handler4, -24(%ebp)
 ; CHECK: movl %fs:0, %[[next:[^ ,]*]]
 ; CHECK: movl %[[next]], -28(%ebp)
 ; CHECK: movl %[[node]], %fs:0
 ; CHECK: calll _may_throw_or_crash
 ; CHECK: movl -28(%ebp), %[[next:[^ ,]*]]
 ; CHECK: movl %[[next]], %fs:0
 ; CHECK: retl
-; CHECK: LBB2_2: # %lpad{{$}}
+; CHECK: LBB2_2: # %catch{{$}}
 
 ; CHECK: .section .xdata,"dr"
 ; CHECK-LABEL: L__ehtable$use_except_handler4:
 ; CHECK-NEXT:  .long   -2
 ; CHECK-NEXT:  .long   0
 ; CHECK-NEXT:  .long   9999
 ; CHECK-NEXT:  .long   0
 ; CHECK-NEXT:  .long   -2
 ; CHECK-NEXT:  .long   _catchall_filt
 ; CHECK-NEXT:  .long   LBB2_2
 
 define void @use_CxxFrameHandler3() personality i32 (...)* @__CxxFrameHandler3 {
   invoke void @may_throw_or_crash()
       to label %cont unwind label %catchall
 cont:
   ret void
 
 catchall:
-  %p = catchpad [i8* null, i32 64, i8* null]
-      to label %catch unwind label %endcatch
-
+  %cs = catchswitch within none [label %catch] unwind to caller
 catch:
-  catchret %p to label %cont
-
-endcatch:
-  catchendpad unwind to caller
+  %p = catchpad within %cs [i8* null, i32 64, i8* null]
+  catchret from %p to label %cont
 }
 
 ; CHECK-LABEL: _use_CxxFrameHandler3:
 ; CHECK: pushl %ebp
 ; CHECK: movl %esp, %ebp
 ; CHECK: subl ${{[0-9]+}}, %esp
 ; CHECK: movl %esp, -28(%ebp)
 ; CHECK: movl $-1, -16(%ebp)

llvm/trunk/test/CodeGen/X86/win32-seh-catchpad-realign.ll

 define void @realigned_try() personality i8* bitcast (i32 (...)* @_except_handler3 to i8*) {
 entry:
   %x = alloca [4 x i32], align 16
   %arrayidx = getelementptr inbounds [4 x i32], [4 x i32]* %x, i32 0, i32 0
   invoke void @useit(i32* %arrayidx)
           to label %__try.cont unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %pad = catchpad [i8* bitcast (i32 ()* @"\01?filt$0@0@realigned_try@@" to i8*)]
-          to label %__except.ret unwind label %catchendblock
+  %cs1 = catchswitch within none [label %__except.ret] unwind to caller
 
 __except.ret:                                     ; preds = %catch.dispatch
-  catchret %pad to label %__try.cont
+  %pad = catchpad within %cs1 [i8* bitcast (i32 ()* @"\01?filt$0@0@realigned_try@@" to i8*)]
+  catchret from %pad to label %__try.cont
 
 __try.cont:                                       ; preds = %entry, %__except.ret
   ret void
-
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind to caller
 }
 
 ; Function Attrs: nounwind argmemonly
 
 ; Function Attrs: nounwind
 define internal i32 @"\01?filt$0@0@realigned_try@@"() {
 entry:
   ret i32 1

 ; CHECK: LBB0_2:       # %__try.cont
 ; CHECK: leal    -12(%ebp), %esp
 ; CHECK: popl    %esi
 ; CHECK: popl    %edi
 ; CHECK: popl    %ebx
 ; CHECK: popl    %ebp
 ; CHECK: retl
 ;
-; CHECK: LBB0_1:                                 # %catch.dispatch
+; CHECK: LBB0_1:                                 # %__except.ret
 ; Restore ESP
 ; CHECK: movl    -24(%ebp), %esp
 ; Recompute ESI by subtracting 60 from the end of the registration node.
 ; CHECK: leal    -60(%ebp), %esi
 ; Restore EBP
 ; CHECK: movl    12(%esi), %ebp
 ; Rejoin normal control flow
 ; CHECK: jmp     LBB0_2

llvm/trunk/test/CodeGen/X86/win32-seh-catchpad.ll

 ; RUN: llc < %s | FileCheck %s
 
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-pc-windows-msvc"
 
 define void @try_except() #0 personality i8* bitcast (i32 (...)* @_except_handler3 to i8*) {
 entry:
   %__exception_code = alloca i32, align 4
   call void (...) @llvm.localescape(i32* %__exception_code)
   invoke void @f(i32 1) #3
           to label %invoke.cont unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %0 = catchpad [i8* bitcast (i32 ()* @try_except_filter_catchall to i8*)] to label %__except.ret unwind label %catchendblock
+  %cs1 = catchswitch within none [label %__except.ret] unwind to caller
 
 __except.ret:                                     ; preds = %catch.dispatch
-  catchret %0 to label %__except
+  %0 = catchpad within %cs1 [i8* bitcast (i32 ()* @try_except_filter_catchall to i8*)]
+  catchret from %0 to label %__except
 
 __except:                                         ; preds = %__except.ret
   call void @f(i32 2)
   br label %__try.cont
 
 __try.cont:                                       ; preds = %__except, %invoke.cont
   call void @f(i32 3)
   ret void
 
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind to caller
-
 invoke.cont:                                      ; preds = %entry
   br label %__try.cont
 }
 
 ; CHECK-LABEL: _try_except:
 ;     Store state #0
 ; CHECK: movl $0, -[[state:[0-9]+]](%ebp)
 ; CHECK: movl $1, (%esp)

 define void @nested_exceptions() #0 personality i8* bitcast (i32 (...)* @_except_handler3 to i8*) {
 entry:
   %__exception_code = alloca i32, align 4
   call void (...) @llvm.localescape(i32* %__exception_code)
   invoke void @crash() #3
           to label %__try.cont unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %0 = catchpad [i8* bitcast (i32 ()* @nested_exceptions_filter_catchall to i8*)] to label %__except.ret unwind label %catchendblock
+  %cs1 = catchswitch within none [label %__except.ret] unwind label %catch.dispatch.11
 
 __except.ret:                                     ; preds = %catch.dispatch
-  catchret %0 to label %__try.cont
+  %0 = catchpad within %cs1 [i8* bitcast (i32 ()* @nested_exceptions_filter_catchall to i8*)]
+  catchret from %0 to label %__try.cont
 
 __try.cont:                                       ; preds = %entry, %__except.ret
   invoke void @crash() #3
           to label %__try.cont.9 unwind label %catch.dispatch.5
 
 catch.dispatch.5:                                 ; preds = %__try.cont
-  %1 = catchpad [i8* bitcast (i32 ()* @nested_exceptions_filter_catchall to i8*)] to label %__except.ret.7 unwind label %catchendblock.6
+  %cs2 = catchswitch within none [label %__except.ret.7] unwind label %catch.dispatch.11
 
 __except.ret.7:                                   ; preds = %catch.dispatch.5
-  catchret %1 to label %__try.cont.9
+  %1 = catchpad within %cs2 [i8* bitcast (i32 ()* @nested_exceptions_filter_catchall to i8*)]
+  catchret from %1 to label %__try.cont.9
 
 __try.cont.9:                                     ; preds = %__try.cont, %__except.ret.7
   invoke void @crash() #3
           to label %__try.cont.15 unwind label %catch.dispatch.11
 
 catch.dispatch.11:                                ; preds = %catchendblock, %catchendblock.6, %__try.cont.9
-  %2 = catchpad [i8* bitcast (i32 ()* @nested_exceptions_filter_catchall to i8*)] to label %__except.ret.13 unwind label %catchendblock.12
+  %cs3 = catchswitch within none [label %__except.ret.13] unwind label %catch.dispatch.17
 
 __except.ret.13:                                  ; preds = %catch.dispatch.11
-  catchret %2 to label %__try.cont.15
+  %2 = catchpad within %cs3 [i8* bitcast (i32 ()* @nested_exceptions_filter_catchall to i8*)]
+  catchret from %2 to label %__try.cont.15
 
 __try.cont.15:                                    ; preds = %__try.cont.9, %__except.ret.13
   invoke void @crash() #3
           to label %__try.cont.35 unwind label %catch.dispatch.17
 
 catch.dispatch.17:                                ; preds = %catchendblock.12, %__try.cont.15
-  %3 = catchpad [i8* bitcast (i32 ()* @nested_exceptions_filter_catchall to i8*)] to label %__except.ret.19 unwind label %catchendblock.18
+  %cs4 = catchswitch within none [label %__except.ret.19] unwind to caller
 
 __except.ret.19:                                  ; preds = %catch.dispatch.17
-  catchret %3 to label %__except.20
+  %3 = catchpad within %cs4 [i8* bitcast (i32 ()* @nested_exceptions_filter_catchall to i8*)]
+  catchret from %3 to label %__except.20
 
 __except.20:                                      ; preds = %__except.ret.19
   invoke void @crash() #3
           to label %__try.cont.27 unwind label %catch.dispatch.23
 
 catch.dispatch.23:                                ; preds = %__except.20
-  %4 = catchpad [i8* bitcast (i32 ()* @nested_exceptions_filter_catchall to i8*)] to label %__except.ret.25 unwind label %catchendblock.24
+  %cs5 = catchswitch within none [label %__except.ret.25] unwind to caller
 
 __except.ret.25:                                  ; preds = %catch.dispatch.23
-  catchret %4 to label %__try.cont.27
+  %4 = catchpad within %cs5 [i8* bitcast (i32 ()* @nested_exceptions_filter_catchall to i8*)]
+  catchret from %4 to label %__try.cont.27
 
 __try.cont.27:                                    ; preds = %__except.20, %__except.ret.25
   invoke void @crash() #3
           to label %__try.cont.35 unwind label %catch.dispatch.30
 
 catch.dispatch.30:                                ; preds = %__try.cont.27
-  %5 = catchpad [i8* bitcast (i32 ()* @nested_exceptions_filter_catchall to i8*)] to label %__except.ret.32 unwind label %catchendblock.31
+  %cs6 = catchswitch within none [label %__except.ret.32] unwind to caller
 
 __except.ret.32:                                  ; preds = %catch.dispatch.30
-  catchret %5 to label %__try.cont.35
+  %5 = catchpad within %cs6 [i8* bitcast (i32 ()* @nested_exceptions_filter_catchall to i8*)]
+  catchret from %5 to label %__try.cont.35
 
 __try.cont.35:                                    ; preds = %__try.cont.15, %__try.cont.27, %__except.ret.32
   ret void
-
-catchendblock.31:                                 ; preds = %catch.dispatch.30
-  catchendpad unwind to caller
-
-catchendblock.24:                                 ; preds = %catch.dispatch.23
-  catchendpad unwind to caller
-
-catchendblock.18:                                 ; preds = %catch.dispatch.17
-  catchendpad unwind to caller
-
-catchendblock.12:                                 ; preds = %catch.dispatch.11
-  catchendpad unwind label %catch.dispatch.17
-
-catchendblock.6:                                  ; preds = %catch.dispatch.5
-  catchendpad unwind label %catch.dispatch.11
-
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind label %catch.dispatch.11
 }
 
 ; This table is equivalent to the one produced by MSVC, even if it isn't in
 ; quite the same order.
 
 ; CHECK-LABEL: _nested_exceptions:
 ; CHECK: L__ehtable$nested_exceptions:
 ; CHECK:         .long   -1
 ; CHECK:         .long   _nested_exceptions_filter_catchall
 ; CHECK:         .long   LBB
-; CHECK:         .long   -1
+; CHECK:         .long   0
 ; CHECK:         .long   _nested_exceptions_filter_catchall
 ; CHECK:         .long   LBB
-; CHECK:         .long   -1
+; CHECK:         .long   1
 ; CHECK:         .long   _nested_exceptions_filter_catchall
 ; CHECK:         .long   LBB
-; CHECK:         .long   2
+; CHECK:         .long   1
 ; CHECK:         .long   _nested_exceptions_filter_catchall
 ; CHECK:         .long   LBB
-; CHECK:         .long   3
+; CHECK:         .long   -1
 ; CHECK:         .long   _nested_exceptions_filter_catchall
 ; CHECK:         .long   LBB
-; CHECK:         .long   3
+; CHECK:         .long   -1
 ; CHECK:         .long   _nested_exceptions_filter_catchall
 ; CHECK:         .long   LBB
 
 declare void @crash() #0
 
 define internal i32 @nested_exceptions_filter_catchall() #0 {
 entry:
   %0 = call i8* @llvm.frameaddress(i32 1)

 }
 
 define void @code_in_catchpad() #0 personality i8* bitcast (i32 (...)* @_except_handler3 to i8*) {
 entry:
   invoke void @f(i32 1) #3
           to label %__except unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %0 = catchpad [i8* bitcast (i32 ()* @try_except_filter_catchall to i8*)] to label %__except.ret unwind label %catchendblock
+  %cs1 = catchswitch within none [label %__except.ret] unwind to caller
 
 __except.ret:                                     ; preds = %catch.dispatch
+  %0 = catchpad within %cs1 [i8* bitcast (i32 ()* @try_except_filter_catchall to i8*)]
   call void @f(i32 2)
-  catchret %0 to label %__except
+  catchret from %0 to label %__except
 
 __except:
   ret void
-
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind to caller
 }
 
 ; CHECK-LABEL: _code_in_catchpad:
-; CHECK: # %catch.dispatch
+; CHECK: # %__except.ret
 ; CHECK-NEXT:         movl    -24(%ebp), %esp
 ; CHECK-NEXT:         addl    $12, %ebp
 ; CHECK-NEXT:         movl    $-1, -16(%ebp)
 ; CHECK-NEXT:         movl    $2, (%esp)
 ; CHECK-NEXT:         calll   _f
 
 
 ; Function Attrs: nounwind readnone

llvm/trunk/test/CodeGen/X86/win32-seh-cleanupendpad.ll

-; RUN: llc < %s | FileCheck %s
-
-target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
-target triple = "i686-pc-windows-msvc"
-
-define void @nested_finally() #0 personality i8* bitcast (i32 (...)* @_except_handler3 to i8*) {
-entry:
-  invoke void @f(i32 1) #3
-          to label %invoke.cont unwind label %ehcleanup
-
-invoke.cont:                                      ; preds = %entry
-  invoke void @f(i32 2) #3
-          to label %invoke.cont.1 unwind label %ehcleanup.3
-
-invoke.cont.1:                                    ; preds = %invoke.cont
-  call void @f(i32 3) #3
-  ret void
-
-ehcleanup:                                        ; preds = %entry
-  %0 = cleanuppad []
-  invoke void @f(i32 2) #3
-          to label %invoke.cont.2 unwind label %ehcleanup.end
-
-invoke.cont.2:                                    ; preds = %ehcleanup
-  cleanupret %0 unwind label %ehcleanup.3
-
-ehcleanup.end:                                    ; preds = %ehcleanup
-  cleanupendpad %0 unwind label %ehcleanup.3
-
-ehcleanup.3:                                      ; preds = %invoke.cont.2, %ehcleanup.end, %invoke.cont
-  %1 = cleanuppad []
-  invoke void @f(i32 3) #3
-          to label %invoke.cont.4 unwind label %ehcleanup.end.5
-
-invoke.cont.4:                                    ; preds = %ehcleanup.3
-  cleanupret %1 unwind to caller
-
-ehcleanup.end.5:                                  ; preds = %ehcleanup.3
-  cleanupendpad %1 unwind to caller
-}
-
-declare void @f(i32) #0
-
-declare i32 @_except_handler3(...)
-
-attributes #0 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
-attributes #1 = { noinline nounwind "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
-attributes #2 = { nounwind readnone }
-attributes #3 = { noinline }
-
-; CHECK: _nested_finally:
-; CHECK: movl $-1, -[[state:[0-9]+]](%ebp)
-; CHECK: movl {{.*}}, %fs:0
-; CHECK: movl $1, -[[state]](%ebp)
-; CHECK: movl $1, (%esp)
-; CHECK: calll _f
-; CHECK: movl $0, -[[state]](%ebp)
-; CHECK: movl $2, (%esp)
-; CHECK: calll _f
-; CHECK: movl $-1, -[[state]](%ebp)
-; CHECK: movl $3, (%esp)
-; CHECK: calll _f
-; CHECK: retl
-
-; CHECK: LBB0_[[inner:[0-9]+]]: # %ehcleanup
-; CHECK: pushl %ebp
-; CHECK: addl $12, %ebp
-; CHECK: movl $0, -[[state]](%ebp)
-; CHECK: movl $2, (%esp)
-; CHECK: calll _f
-; CHECK: popl %ebp
-; CHECK: retl
-
-; CHECK: LBB0_[[outer:[0-9]+]]: # %ehcleanup.3
-; CHECK: pushl %ebp
-; CHECK: addl $12, %ebp
-; CHECK: movl $-1, -[[state]](%ebp)
-; CHECK: movl $3, (%esp)
-; CHECK: calll _f
-; CHECK: popl %ebp
-; CHECK: retl
-
-; CHECK: L__ehtable$nested_finally:
-; CHECK:        .long   -1
-; CHECK:        .long   0
-; CHECK:        .long   LBB0_[[outer]]
-; CHECK:        .long   0
-; CHECK:        .long   0
-; CHECK:        .long   LBB0_[[inner]]

llvm/trunk/test/CodeGen/X86/win32-seh-nested-finally.ll

+; RUN: llc < %s | FileCheck %s
+
+target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
+target triple = "i686-pc-windows-msvc"
+
+define void @nested_finally() #0 personality i8* bitcast (i32 (...)* @_except_handler3 to i8*) {
+entry:
+  invoke void @f(i32 1) #3
+          to label %invoke.cont unwind label %ehcleanup
+
+invoke.cont:                                      ; preds = %entry
+  invoke void @f(i32 2) #3
+          to label %invoke.cont.1 unwind label %ehcleanup.3
+
+invoke.cont.1:                                    ; preds = %invoke.cont
+  call void @f(i32 3) #3
+  ret void
+
+ehcleanup:                                        ; preds = %entry
+  %0 = cleanuppad within none []
+  invoke void @f(i32 2) #3
+          to label %invoke.cont.2 unwind label %ehcleanup.3
+
+invoke.cont.2:                                    ; preds = %ehcleanup
+  cleanupret from %0 unwind label %ehcleanup.3
+
+ehcleanup.3:                                      ; preds = %invoke.cont.2, %ehcleanup.end, %invoke.cont
+  %1 = cleanuppad within none []
+  call void @f(i32 3) #3
+  cleanupret from %1 unwind to caller
+}
+
+declare void @f(i32) #0
+
+declare i32 @_except_handler3(...)
+
+attributes #0 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { noinline nounwind "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #2 = { nounwind readnone }
+attributes #3 = { noinline }
+
+; CHECK: _nested_finally:
+; CHECK: movl $-1, -[[state:[0-9]+]](%ebp)
+; CHECK: movl {{.*}}, %fs:0
+; CHECK: movl $1, -[[state]](%ebp)
+; CHECK: movl $1, (%esp)
+; CHECK: calll _f
+; CHECK: movl $0, -[[state]](%ebp)
+; CHECK: movl $2, (%esp)
+; CHECK: calll _f
+; CHECK: movl $-1, -[[state]](%ebp)
+; CHECK: movl $3, (%esp)
+; CHECK: calll _f
+; CHECK: retl
+
+; CHECK: LBB0_[[inner:[0-9]+]]: # %ehcleanup
+; CHECK: pushl %ebp
+; CHECK: addl $12, %ebp
+; CHECK: movl $0, -[[state]](%ebp)
+; CHECK: movl $2, (%esp)
+; CHECK: calll _f
+; CHECK: popl %ebp
+; CHECK: retl
+
+; CHECK: LBB0_[[outer:[0-9]+]]: # %ehcleanup.3
+; CHECK: pushl %ebp
+; CHECK: addl $12, %ebp
+; CHECK: movl $-1, -[[state]](%ebp)
+; CHECK: movl $3, (%esp)
+; CHECK: calll _f
+; CHECK: popl %ebp
+; CHECK: retl
+
+; CHECK: L__ehtable$nested_finally:
+; CHECK:        .long   -1
+; CHECK:        .long   0
+; CHECK:        .long   LBB0_[[outer]]
+; CHECK:        .long   0
+; CHECK:        .long   0
+; CHECK:        .long   LBB0_[[inner]]

llvm/trunk/test/CodeGen/X86/wineh-coreclr.ll

+; RUN: llc -mtriple=x86_64-pc-windows-coreclr -verify-machineinstrs < %s | FileCheck %s
+
+declare void @ProcessCLRException()
+declare void @f(i32)
+declare void @g(i8 addrspace(1)*)
+declare i8 addrspace(1)* @llvm.eh.exceptionpointer.p1i8(token)
+
+; Simplified IR for pseudo-C# like the following:
+; void test1() {
+;   try {
+;     f(1);
+;     try {
+;       f(2);
+;     } catch (type1) {
+;       f(3);
+;     } catch (type2) {
+;       f(4);
+;       try {
+;         f(5);
+;       } fault {
+;         f(6);
+;       }
+;     }
+;   } finally {
+;     f(7);
+;   }
+;   f(8);
+; }
+
+; CHECK-LABEL: test1:     # @test1
+; CHECK-NEXT: [[L_begin:.*func_begin.*]]:
+define void @test1() personality i8* bitcast (void ()* @ProcessCLRException to i8*) {
+entry:
+; CHECK: # %entry
+; CHECK: leaq [[FPOffset:[0-9]+]](%rsp), %rbp
+; CHECK: .seh_endprologue
+; CHECK: movq %rsp, [[PSPSymOffset:[0-9]+]](%rsp)
+; CHECK: [[L_before_f1:.+]]:
+; CHECK-NEXT: movl $1, %ecx
+; CHECK-NEXT: callq f
+; CHECK-NEXT: [[L_after_f1:.+]]:
+  invoke void @f(i32 1)
+    to label %inner_try unwind label %finally.pad
+inner_try:
+; CHECK: # %inner_try
+; CHECK: [[L_before_f2:.+]]:
+; CHECK-NEXT: movl $2, %ecx
+; CHECK-NEXT: callq f
+; CHECK-NEXT: [[L_after_f2:.+]]:
+  invoke void @f(i32 2)
+    to label %finally.clone unwind label %catch1.pad
+catch1.pad:
+  %cs1 = catchswitch within none [label %catch1.body, label %catch2.body] unwind label %finally.pad
+catch1.body:
+  %catch1 = catchpad within %cs1 [i32 1]
+; CHECK: .seh_proc [[L_catch1:[^ ]+]]
+; CHECK: .seh_stackalloc [[FuncletFrameSize:[0-9]+]]
+;                        ^ all funclets use the same frame size
+; CHECK: movq [[PSPSymOffset]](%rcx), %rcx
+;                              ^ establisher frame pointer passed in rcx
+; CHECK: movq %rcx, [[PSPSymOffset]](%rsp)
+; CHECK: leaq [[FPOffset]](%rcx), %rbp
+; CHECK: .seh_endprologue
+; CHECK: movq %rdx, %rcx
+;             ^ exception pointer passed in rdx
+; CHECK-NEXT: callq g
+  %exn1 = call i8 addrspace(1)* @llvm.eh.exceptionpointer.p1i8(token %catch1)
+  call void @g(i8 addrspace(1)* %exn1)
+; CHECK: [[L_before_f3:.+]]:
+; CHECK-NEXT: movl $3, %ecx
+; CHECK-NEXT: callq f
+; CHECK-NEXT: [[L_after_f3:.+]]:
+  invoke void @f(i32 3)
+    to label %catch1.ret unwind label %finally.pad
+catch1.ret:
+  catchret from %catch1 to label %finally.clone
+catch2.body:
+  %catch2 = catchpad within %cs1 [i32 2]
+; CHECK: .seh_proc [[L_catch2:[^ ]+]]
+; CHECK: .seh_stackalloc [[FuncletFrameSize:[0-9]+]]
+;                        ^ all funclets use the same frame size
+; CHECK: movq [[PSPSymOffset]](%rcx), %rcx
+;                              ^ establisher frame pointer passed in rcx
+; CHECK: movq %rcx, [[PSPSymOffset]](%rsp)
+; CHECK: leaq [[FPOffset]](%rcx), %rbp
+; CHECK: .seh_endprologue
+; CHECK: movq %rdx, %rcx
+;             ^ exception pointer passed in rdx
+; CHECK-NEXT: callq g
+  %exn2 = call i8 addrspace(1)* @llvm.eh.exceptionpointer.p1i8(token %catch2)
+  call void @g(i8 addrspace(1)* %exn2)
+; CHECK: [[L_before_f4:.+]]:
+; CHECK-NEXT: movl $4, %ecx
+; CHECK-NEXT: callq f
+; CHECK-NEXT: [[L_after_f4:.+]]:
+  invoke void @f(i32 4)
+    to label %try_in_catch unwind label %finally.pad
+try_in_catch:
+; CHECK: # %try_in_catch
+; CHECK: [[L_before_f5:.+]]:
+; CHECK-NEXT: movl $5, %ecx
+; CHECK-NEXT: callq f
+; CHECK-NEXT: [[L_after_f5:.+]]:
+  invoke void @f(i32 5)
+    to label %catch2.ret unwind label %fault.pad
+fault.pad:
+; CHECK: .seh_proc [[L_fault:[^ ]+]]
+  %fault = cleanuppad within none [i32 undef]
+; CHECK: .seh_stackalloc [[FuncletFrameSize:[0-9]+]]
+;                        ^ all funclets use the same frame size
+; CHECK: movq [[PSPSymOffset]](%rcx), %rcx
+;                              ^ establisher frame pointer passed in rcx
+; CHECK: movq %rcx, [[PSPSymOffset]](%rsp)
+; CHECK: leaq [[FPOffset]](%rcx), %rbp
+; CHECK: .seh_endprologue
+; CHECK: [[L_before_f6:.+]]:
+; CHECK-NEXT: movl $6, %ecx
+; CHECK-NEXT: callq f
+; CHECK-NEXT: [[L_after_f6:.+]]:
+  invoke void @f(i32 6)
+    to label %fault.ret unwind label %finally.pad
+fault.ret:
+  cleanupret from %fault unwind label %finally.pad
+catch2.ret:
+  catchret from %catch2 to label %finally.clone
+finally.clone:
+  call void @f(i32 7)
+  br label %tail
+finally.pad:
+; CHECK: .seh_proc [[L_finally:[^ ]+]]
+  %finally = cleanuppad within none []
+; CHECK: .seh_stackalloc [[FuncletFrameSize:[0-9]+]]
+;                        ^ all funclets use the same frame size
+; CHECK: movq [[PSPSymOffset]](%rcx), %rcx
+;                              ^ establisher frame pointer passed in rcx
+; CHECK: movq %rcx, [[PSPSymOffset]](%rsp)
+; CHECK: leaq [[FPOffset]](%rcx), %rbp
+; CHECK: .seh_endprologue
+; CHECK-NEXT: movl $7, %ecx
+; CHECK-NEXT: callq f
+  call void @f(i32 7)
+  cleanupret from %finally unwind to caller
+tail:
+  call void @f(i32 8)
+  ret void
+; CHECK: [[L_end:.*func_end.*]]:
+}
+
+; FIXME: Verify that the new clauses are correct and re-enable these checks.
+
+; Now check for EH table in xdata (following standard xdata)
+; CHECKX-LABEL: .section .xdata
+; standard xdata comes here
+; CHECKX:      .long 4{{$}}
+;                   ^ number of funclets
+; CHECKX-NEXT: .long [[L_catch1]]-[[L_begin]]
+;                   ^ offset from L_begin to start of 1st funclet
+; CHECKX-NEXT: .long [[L_catch2]]-[[L_begin]]
+;                   ^ offset from L_begin to start of 2nd funclet
+; CHECKX-NEXT: .long [[L_fault]]-[[L_begin]]
+;                   ^ offset from L_begin to start of 3rd funclet
+; CHECKX-NEXT: .long [[L_finally]]-[[L_begin]]
+;                   ^ offset from L_begin to start of 4th funclet
+; CHECKX-NEXT: .long [[L_end]]-[[L_begin]]
+;                   ^ offset from L_begin to end of last funclet
+; CHECKX-NEXT: .long 7
+;                   ^ number of EH clauses
+; Clause 1: call f(2) is guarded by catch1
+; CHECKX-NEXT: .long 0
+;                   ^ flags (0 => catch handler)
+; CHECKX-NEXT: .long ([[L_before_f2]]-[[L_begin]])+1
+;                   ^ offset of start of clause
+; CHECKX-NEXT: .long ([[L_after_f2]]-[[L_begin]])+1
+;                   ^ offset of end of clause
+; CHECKX-NEXT: .long [[L_catch1]]-[[L_begin]]
+;                   ^ offset of start of handler
+; CHECKX-NEXT: .long [[L_catch2]]-[[L_begin]]
+;                   ^ offset of end of handler
+; CHECKX-NEXT: .long 1
+;                   ^ type token of catch (from catchpad)
+; Clause 2: call f(2) is also guarded by catch2
+; CHECKX-NEXT: .long 0
+;                   ^ flags (0 => catch handler)
+; CHECKX-NEXT: .long ([[L_before_f2]]-[[L_begin]])+1
+;                   ^ offset of start of clause
+; CHECKX-NEXT: .long ([[L_after_f2]]-[[L_begin]])+1
+;                   ^ offset of end of clause
+; CHECKX-NEXT: .long [[L_catch2]]-[[L_begin]]
+;                   ^ offset of start of handler
+; CHECKX-NEXT: .long [[L_fault]]-[[L_begin]]
+;                   ^ offset of end of handler
+; CHECKX-NEXT: .long 2
+;                   ^ type token of catch (from catchpad)
+; Clause 3: calls f(1) and f(2) are guarded by finally
+; CHECKX-NEXT: .long 2
+;                   ^ flags (2 => finally handler)
+; CHECKX-NEXT: .long ([[L_before_f1]]-[[L_begin]])+1
+;                   ^ offset of start of clause
+; CHECKX-NEXT: .long ([[L_after_f2]]-[[L_begin]])+1
+;                   ^ offset of end of clause
+; CHECKX-NEXT: .long [[L_finally]]-[[L_begin]]
+;                   ^ offset of start of handler
+; CHECKX-NEXT: .long [[L_end]]-[[L_begin]]
+;                   ^ offset of end of handler
+; CHECKX-NEXT: .long 0
+;                   ^ type token slot (null for finally)
+; Clause 4: call f(3) is guarded by finally
+;           This is a "duplicate" because the protected range (f(3))
+;           is in funclet catch1 but the finally's immediate parent
+;           is the main function, not that funclet.
+; CHECKX-NEXT: .long 10
+;                   ^ flags (2 => finally handler | 8 => duplicate)
+; CHECKX-NEXT: .long ([[L_before_f3]]-[[L_begin]])+1
+;                   ^ offset of start of clause
+; CHECKX-NEXT: .long ([[L_after_f3]]-[[L_begin]])+1
+;                   ^ offset of end of clause
+; CHECKX-NEXT: .long [[L_finally]]-[[L_begin]]
+;                   ^ offset of start of handler
+; CHECKX-NEXT: .long [[L_end]]-[[L_begin]]
+;                   ^ offset of end of handler
+; CHECKX-NEXT: .long 0
+;                   ^ type token slot (null for finally)
+; Clause 5: call f(5) is guarded by fault
+; CHECKX-NEXT: .long 4
+;                   ^ flags (4 => fault handler)
+; CHECKX-NEXT: .long ([[L_before_f5]]-[[L_begin]])+1
+;                   ^ offset of start of clause
+; CHECKX-NEXT: .long ([[L_after_f5]]-[[L_begin]])+1
+;                   ^ offset of end of clause
+; CHECKX-NEXT: .long [[L_fault]]-[[L_begin]]
+;                   ^ offset of start of handler
+; CHECKX-NEXT: .long [[L_finally]]-[[L_begin]]
+;                   ^ offset of end of handler
+; CHECKX-NEXT: .long 0
+;                   ^ type token slot (null for fault)
+; Clause 6: calls f(4) and f(5) are guarded by finally
+;           This is a "duplicate" because the protected range (f(4)-f(5))
+;           is in funclet catch2 but the finally's immediate parent
+;           is the main function, not that funclet.
+; CHECKX-NEXT: .long 10
+;                   ^ flags (2 => finally handler | 8 => duplicate)
+; CHECKX-NEXT: .long ([[L_before_f4]]-[[L_begin]])+1
+;                   ^ offset of start of clause
+; CHECKX-NEXT: .long ([[L_after_f5]]-[[L_begin]])+1
+;                   ^ offset of end of clause
+; CHECKX-NEXT: .long [[L_finally]]-[[L_begin]]
+;                   ^ offset of start of handler
+; CHECKX-NEXT: .long [[L_end]]-[[L_begin]]
+;                   ^ offset of end of handler
+; CHECKX-NEXT: .long 0
+;                   ^ type token slot (null for finally)
+; Clause 7: call f(6) is guarded by finally
+;           This is a "duplicate" because the protected range (f(3))
+;           is in funclet catch1 but the finally's immediate parent
+;           is the main function, not that funclet.
+; CHECKX-NEXT: .long 10
+;                   ^ flags (2 => finally handler | 8 => duplicate)
+; CHECKX-NEXT: .long ([[L_before_f6]]-[[L_begin]])+1
+;                   ^ offset of start of clause
+; CHECKX-NEXT: .long ([[L_after_f6]]-[[L_begin]])+1
+;                   ^ offset of end of clause
+; CHECKX-NEXT: .long [[L_finally]]-[[L_begin]]
+;                   ^ offset of start of handler
+; CHECKX-NEXT: .long [[L_end]]-[[L_begin]]
+;                   ^ offset of end of handler
+; CHECKX-NEXT: .long 0
+;                   ^ type token slot (null for finally)

llvm/trunk/test/CodeGen/X86/wineh-exceptionpointer.ll

+; RUN: llc -mtriple=x86_64-pc-windows-coreclr < %s | FileCheck %s
+
+declare void @ProcessCLRException()
+declare i8 addrspace(1)* @llvm.eh.exceptionpointer.p1i8(token)
+declare void @f()
+declare void @g(i32 addrspace(1)*)
+
+; CHECK-LABEL: test1: # @test1
+define void @test1() personality i8* bitcast (void ()* @ProcessCLRException to i8*) {
+entry:
+  invoke void @f()
+    to label %exit unwind label %catch.pad
+catch.pad:
+  %cs1 = catchswitch within none [label %catch.body] unwind to caller
+catch.body:
+  ; CHECK: {{^[^: ]+}}: # %catch.body
+  ; CHECK: movq %rdx, %rcx
+  ; CHECK-NEXT: callq g
+  %catch = catchpad within %cs1 [i32 5]
+  %exn = call i8 addrspace(1)* @llvm.eh.exceptionpointer.p1i8(token %catch)
+  %cast_exn = bitcast i8 addrspace(1)* %exn to i32 addrspace(1)*
+  call void @g(i32 addrspace(1)* %cast_exn)
+  catchret from %catch to label %exit
+exit:
+  ret void
+}

llvm/trunk/test/Feature/exception.ll

 
 declare i32 @__gxx_personality_v0(...)
 
 define void @cleanupret0() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @_Z3quxv() optsize
           to label %exit unwind label %pad
 pad:
-  %cp = cleanuppad [i7 4]
-  cleanupret %cp unwind to caller
+  %cp = cleanuppad within none [i7 4]
+  cleanupret from %cp unwind to caller
 exit:
   ret void
 }
 
 ; forward ref by name
 define void @cleanupret1() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @_Z3quxv() optsize
           to label %exit unwind label %pad
 cleanup:
-  cleanupret %cp unwind label %pad
+  cleanupret from %cp unwind label %pad
 pad:
-  %cp = cleanuppad []
+  %cp = cleanuppad within none []
   br label %cleanup
 exit:
   ret void
 }
 
 ; forward ref by ID
 define void @cleanupret2() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @_Z3quxv() optsize
           to label %exit unwind label %pad
 cleanup:
-  cleanupret %0 unwind label %pad
+  cleanupret from %0 unwind label %pad
 pad:
-  %0 = cleanuppad []
+  %0 = cleanuppad within none []
   br label %cleanup
 exit:
   ret void
 }
 
 define void @catchret0() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @_Z3quxv() optsize
           to label %exit unwind label %pad
 pad:
-  %cp = catchpad [i7 4]
-          to label %catch unwind label %endpad
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 catch:
-  catchret %cp to label %exit
-endpad:
-  catchendpad unwind to caller
+  %cp = catchpad within %cs1 [i7 4]
+  catchret from %cp to label %exit
 exit:
   ret void
 }
 
 ; forward ref by name
 define void @catchret1() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @_Z3quxv() optsize
           to label %exit unwind label %pad
-catch:
-  catchret %cp to label %exit
+catchret:
+  catchret from %cp to label %exit
 pad:
-  %cp = catchpad []
-          to label %catch unwind label %endpad
-endpad:
-  catchendpad unwind to caller
+  %cs1 = catchswitch within none [label %catch] unwind to caller
+catch:
+  %cp = catchpad within %cs1 [i7 4]
+  br label %catchret
 exit:
   ret void
 }
 
 ; forward ref by ID
 define void @catchret2() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @_Z3quxv() optsize
           to label %exit unwind label %pad
-catch:
-  catchret %0 to label %exit
+catchret:
+  catchret from %0 to label %exit
 pad:
-  %0 = catchpad []
-          to label %catch unwind label %endpad
-endpad:
-  catchendpad unwind to caller
+  %cs1 = catchswitch within none [label %catch] unwind to caller
+catch:
+  %0 = catchpad within %cs1 [i7 4]
+  br label %catchret
 exit:
   ret void
 }
 
 define i8 @catchpad() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @_Z3quxv() optsize
           to label %exit unwind label %bb2
 bb2:
-  catchpad [i7 4] to label %exit unwind label %bb3
-bb3:
-  catchendpad unwind to caller
+  %cs1 = catchswitch within none [label %catch] unwind to caller
+catch:
+  catchpad within %cs1 [i7 4]
+  br label %exit
 exit:
   ret i8 0
 }
 
 define void @terminatepad0() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   br label %try.cont
 
 try.cont:
   invoke void @_Z3quxv() optsize
           to label %try.cont unwind label %bb
 bb:
-  terminatepad [i7 4] unwind label %bb
+  terminatepad within none [i7 4] unwind label %bb
 }
 
 define void @terminatepad1() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   br label %try.cont
 
 try.cont:
   invoke void @_Z3quxv() optsize
           to label %try.cont unwind label %bb
 bb:
-  terminatepad [i7 4] unwind to caller
+  terminatepad within none [i7 4] unwind to caller
 }
 
 define void @cleanuppad() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   br label %try.cont
 
 try.cont:
   invoke void @_Z3quxv() optsize
           to label %try.cont unwind label %bb
 bb:
-  cleanuppad [i7 4]
-  ret void
-}
-
-define void @catchendpad0() personality i32 (...)* @__gxx_personality_v0 {
-entry:
-  br label %try.cont
-
-try.cont:
-  invoke void @_Z3quxv() optsize
-          to label %try.cont unwind label %bb
-bb:
-  catchendpad unwind label %bb
-}
-
-define void @catchendpad1() personality i32 (...)* @__gxx_personality_v0 {
-entry:
-  br label %try.cont
-
-try.cont:
-  invoke void @_Z3quxv() optsize
-          to label %try.cont unwind label %bb
-bb:
-  catchendpad unwind to caller
-}
-
-define void @cleanupendpad0() personality i32 (...)* @__gxx_personality_v0 {
-entry:
-  invoke void @_Z3quxv() optsize
-          to label %exit unwind label %pad
-pad:
-  %cp = cleanuppad [i7 4]
-  invoke void @_Z3quxv() optsize
-          to label %stop unwind label %endpad
-stop:
-  unreachable
-endpad:
-  cleanupendpad %cp unwind label %pad
-exit:
-  ret void
-}
-
-; forward ref by name
-define void @cleanupendpad1() personality i32 (...)* @__gxx_personality_v0 {
-entry:
-  invoke void @_Z3quxv() optsize
-          to label %exit unwind label %pad
-endpad:
-  cleanupendpad %cp unwind to caller
-pad:
-  %cp = cleanuppad []
-  invoke void @_Z3quxv() optsize
-          to label %stop unwind label %endpad
-stop:
-  unreachable
-exit:
-  ret void
-}
-
-; forward ref by ID
-define void @cleanupendpad2() personality i32 (...)* @__gxx_personality_v0 {
-entry:
-  invoke void @_Z3quxv() optsize
-          to label %exit unwind label %pad
-endpad:
-  cleanupendpad %0 unwind label %pad
-pad:
-  %0 = cleanuppad []
-  invoke void @_Z3quxv() optsize
-          to label %stop unwind label %endpad
-stop:
-  unreachable
-exit:
+  cleanuppad within none [i7 4]
   ret void
 }

llvm/trunk/test/Transforms/CodeGenPrepare/catchpad-phi-cast.ll

 declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #2
 
 ; CodeGenPrepare will want to sink these bitcasts, but it selects the catchpad
 ; blocks as the place to which the bitcast should be sunk.  Since catchpads
 ; do not allow non-phi instructions before the terminator, this isn't possible. 
 
 ; CHECK-LABEL: @test(
 define void @test(i32* %addr) personality i32 (...)* @__CxxFrameHandler3 {
-; CHECK: entry:
-; CHECK-NEXT: %x = getelementptr i32, i32* %addr, i32 1
-; CHECK-NEXT: %p1 = bitcast i32* %x to i8*
 entry:
   %x = getelementptr i32, i32* %addr, i32 1
   %p1 = bitcast i32* %x to i8*
   invoke void @f()
           to label %invoke.cont unwind label %catch1
 
 ; CHECK: invoke.cont:
 ; CHECK-NEXT: %y = getelementptr i32, i32* %addr, i32 2
-; CHECK-NEXT: %p2 = bitcast i32* %y to i8*
 invoke.cont:
   %y = getelementptr i32, i32* %addr, i32 2
   %p2 = bitcast i32* %y to i8*
   invoke void @f()
           to label %done unwind label %catch2
 
 done:
   ret void
 
 catch1:
-  %cp1 = catchpad [] to label %catch.dispatch unwind label %catchend1
+  %cs1 = catchswitch within none [label %handler1] unwind to caller
+
+handler1:
+  %cp1 = catchpad within %cs1 []
+  br label %catch.shared
+; CHECK: handler1:
+; CHECK-NEXT: catchpad within %cs1
+; CHECK: %[[p1:[0-9]+]] = bitcast i32* %x to i8*
 
 catch2:
-  %cp2 = catchpad [] to label %catch.dispatch unwind label %catchend2
+  %cs2 = catchswitch within none [label %handler2] unwind to caller
 
-; CHECK: catch.dispatch:
-; CHECK-NEXT: %p = phi i8* [ %p1, %catch1 ], [ %p2, %catch2 ]
-catch.dispatch:
-  %p = phi i8* [ %p1, %catch1 ], [ %p2, %catch2 ]
+handler2:
+  %cp2 = catchpad within %cs2 []
+  br label %catch.shared
+; CHECK: handler2:
+; CHECK: catchpad within %cs2
+; CHECK: %[[p2:[0-9]+]] = bitcast i32* %y to i8*
+
+; CHECK: catch.shared:
+; CHECK-NEXT: %p = phi i8* [ %[[p1]], %handler1 ], [ %[[p2]], %handler2 ]
+catch.shared:
+  %p = phi i8* [ %p1, %handler1 ], [ %p2, %handler2 ]
   call void @g(i8* %p)
   unreachable
-
-catchend1:
-  catchendpad unwind to caller
-
-catchend2:
-  catchendpad unwind to caller
 }
 
 ; CodeGenPrepare will want to hoist these llvm.dbg.value calls to the phi, but
 ; there is no insertion point in a catchpad block.
 
 ; CHECK-LABEL: @test_dbg_value(
 define void @test_dbg_value() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   %a = alloca i8
   %b = alloca i8
   invoke void @f() to label %next unwind label %catch.dispatch
 next:
   invoke void @f() to label %ret unwind label %catch.dispatch
 ret:
   ret void
 
 catch.dispatch:
   %p = phi i8* [%a, %entry], [%b, %next]
-  %cp1 = catchpad [] to label %catch unwind label %catchend
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:
+  %cp1 = catchpad within %cs1 []
   tail call void @llvm.dbg.value(metadata i8* %p, i64 0, metadata !11, metadata !13), !dbg !14
-  invoke void @g(i8* %p) to label %catchret unwind label %catchend
-catchret:
-  catchret %cp1 to label %ret
+  call void @g(i8* %p)
+  catchret from %cp1 to label %ret
 
 ; CHECK: catch.dispatch:
 ; CHECK-NEXT: phi i8
-; CHECK-NEXT: catchpad
+; CHECK-NEXT: catchswitch
 ; CHECK-NOT: llvm.dbg.value
 
 ; CHECK: catch:
+; CHECK-NEXT: catchpad
 ; CHECK-NEXT: call void @llvm.dbg.value
-
-catchend:
-  catchendpad unwind to caller
 }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!7, !8, !9}
 !llvm.ident = !{!10}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.8.0 (trunk 254906) (llvm/trunk 254917)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: null, subprograms: !3)
 !1 = !DIFile(filename: "t.c", directory: "D:\5Csrc\5Cllvm\5Cbuild")

llvm/trunk/test/Transforms/GVN/funclet.ll

entry:
   %b = alloca i8
   %c = alloca i8
   store i8 42, i8* %b
   store i8 13, i8* %c
   invoke void @_CxxThrowException(i8* %b, %eh.ThrowInfo* nonnull @"_TI1?AUA@@")
           to label %unreachable unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %catchpad = catchpad [i8* null, i32 64, i8* null]
-          to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:                                            ; preds = %catch.dispatch
+  %catchpad = catchpad within %cs1 [i8* null, i32 64, i8* null]
   store i8 5, i8* %b
-  catchret %catchpad to label %try.cont
+  catchret from %catchpad to label %try.cont
 
 try.cont:                                         ; preds = %catch
   %load_b = load i8, i8* %b
   %load_c = load i8, i8* %c
   %add = add i8 %load_b, %load_c
   ret i8 %add
 
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind to caller
-
 unreachable:                                      ; preds = %entry
   unreachable
 }
 ; CHECK-LABEL: define i8 @f(
 ; CHECK:       %[[load_b:.*]] = load i8, i8* %b
 ; CHECK-NEXT:  %[[load_c:.*]] = load i8, i8* %c
 ; CHECK-NEXT:  %[[add:.*]] = add i8 %[[load_b]], %[[load_c]]
 ; CHECK-NEXT:  ret i8 %[[add]]
 
 declare i32 @__CxxFrameHandler3(...)
 
 declare x86_stdcallcc void @_CxxThrowException(i8*, %eh.ThrowInfo*)

llvm/trunk/test/Transforms/GVN/pre-load.ll

 declare void @g(i32)
 declare i32 @__CxxFrameHandler3(...)
 
 ; Test that loads aren't PRE'd into EH pads.
 define void @test12(i32* %p) personality i32 (...)* @__CxxFrameHandler3 {
 ; CHECK-LABEL: @test12(
 block1:
   invoke void @f()
-          to label %block2 unwind label %catch
+          to label %block2 unwind label %catch.dispatch
 
 block2:
   invoke void @f()
           to label %block3 unwind label %cleanup
 
 block3:
   ret void
 
-catch:
-  %c = catchpad []
-    to label %catch.dispatch unwind label %catchend
-
 catch.dispatch:
-  catchret %c to label %block2
+  %cs1 = catchswitch within none [label %catch] unwind label %cleanup2
 
-; CHECK: catchend:
-; CHECK-NOT: load
-; CHECK-NEXT: catchendpad
-catchend:
-  catchendpad unwind label %cleanup2
+catch:
+  %c = catchpad within %cs1 []
+  catchret from %c to label %block2
 
 cleanup:
-  %c1 = cleanuppad []
+  %c1 = cleanuppad within none []
   store i32 0, i32* %p
-  cleanupret %c1 unwind label %cleanup2
+  cleanupret from %c1 unwind label %cleanup2
 
 ; CHECK: cleanup2:
 ; CHECK-NOT: phi
-; CHECK-NEXT: %c2 = cleanuppad []
+; CHECK-NEXT: %c2 = cleanuppad within none []
 ; CHECK-NEXT: %NOTPRE = load i32, i32* %p
 cleanup2:
-  %c2 = cleanuppad []
+  %c2 = cleanuppad within none []
   %NOTPRE = load i32, i32* %p
   call void @g(i32 %NOTPRE)
-  cleanupret %c2 unwind to caller
+  cleanupret from %c2 unwind to caller
 }

llvm/trunk/test/Transforms/Inline/PR25155.ll

 ; RUN: opt < %s -inline -S | FileCheck %s
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc18.0.0"
 
 define void @f() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   invoke void @g()
           to label %try.cont unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
-  %0 = catchpad [i8* null, i32 64, i8* null]
-          to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:                                            ; preds = %catch.dispatch
+  %0 = catchpad within %cs1 [i8* null, i32 64, i8* null]
   invoke void @dtor()
-          to label %invoke.cont.1 unwind label %catchendblock
+          to label %invoke.cont.1 unwind label %ehcleanup
 
 invoke.cont.1:                                    ; preds = %catch
-  catchret %0 to label %try.cont
+  catchret from %0 to label %try.cont
 
 try.cont:                                         ; preds = %entry, %invoke.cont.1
   ret void
 
-catchendblock:                                    ; preds = %catch, %catch.dispatch
-  catchendpad unwind to caller
+ehcleanup:
+  %cp2 = cleanuppad within none []
+  call void @g()
+  cleanupret from %cp2 unwind to caller
 }
 
 ; CHECK-LABEL:  define void @f(
 
 ; CHECK:         invoke void @g()
 ; CHECK:                 to label %dtor.exit unwind label %terminate.i
 
 ; CHECK:       terminate.i:
-; CHECK-NEXT:    terminatepad [void ()* @terminate] unwind label %catchendblock
-
-; CHECK:       catchendblock:
-; CHECK-NEXT:    catchendpad unwind to caller
+; CHECK-NEXT:    terminatepad within %0 [void ()* @terminate] unwind label %ehcleanup
 
 declare i32 @__CxxFrameHandler3(...)
 
 define internal void @dtor() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   invoke void @g()
           to label %invoke.cont unwind label %terminate
 
 invoke.cont:                                      ; preds = %entry
   ret void
 
 terminate:                                        ; preds = %entry
-  terminatepad [void ()* @terminate] unwind to caller
+  terminatepad within none [void ()* @terminate] unwind to caller
 }
 
 declare void @g()
 declare void @terminate()

llvm/trunk/test/Transforms/InstCombine/token.ll

 ; RUN: opt < %s -instcombine -S | FileCheck %s
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc18.0.0"
 
 declare i32 @__CxxFrameHandler3(...)
 
 define void @test1() personality i32 (...)* @__CxxFrameHandler3 {
 bb:
   unreachable
 
 unreachable:
-  %cl = cleanuppad []
-  cleanupret %cl unwind to caller
+  %cl = cleanuppad within none []
+  cleanupret from %cl unwind to caller
 }
 
 ; CHECK-LABEL: define void @test1(
 ; CHECK: unreachable:
-; CHECK:   %cl = cleanuppad []
-; CHECK:   cleanupret %cl unwind to caller
+; CHECK:   %cl = cleanuppad within none []
+; CHECK:   cleanupret from %cl unwind to caller
 
 define void @test2(i8 %A, i8 %B) personality i32 (...)* @__CxxFrameHandler3 {
 bb:
   %X = zext i8 %A to i32
   invoke void @g(i32 0)
     to label %cont
     unwind label %catch
 
 cont:
   %Y = zext i8 %B to i32
   invoke void @g(i32 0)
     to label %unreachable
     unwind label %catch
 
 catch:
   %phi = phi i32 [ %X, %bb ], [ %Y, %cont ]
-  %cl = catchpad []
-   to label %doit
-   unwind label %endpad
+  %cs = catchswitch within none [label %doit] unwind to caller
 
 doit:
+  %cl = catchpad within %cs []
   call void @g(i32 %phi)
   unreachable
 
 unreachable:
   unreachable
-
-endpad:
-  catchendpad unwind to caller
 }
 
 ; CHECK-LABEL: define void @test2(
 ; CHECK:  %X = zext i8 %A to i32
 ; CHECK:  %Y = zext i8 %B to i32
 ; CHECK:  %phi = phi i32 [ %X, %bb ], [ %Y, %cont ]
 
 define void @test3(i8 %A, i8 %B) personality i32 (...)* @__CxxFrameHandler3 {

 
 cont2:
   invoke void @g(i32 0)
     to label %unreachable
     unwind label %catch
 
 catch:
   %phi = phi i32 [ %X, %bb ], [ %Y, %cont ], [ %Y, %cont2 ]
-  %cl = catchpad []
-   to label %doit
-   unwind label %endpad
+  %cs = catchswitch within none [label %doit] unwind to caller
 
 doit:
+  %cl = catchpad within %cs []
   call void @g(i32 %phi)
   unreachable
 
 unreachable:
   unreachable
-
-endpad:
-  catchendpad unwind to caller
 }
 
 ; CHECK-LABEL: define void @test3(
 ; CHECK:  %X = zext i8 %A to i32
 ; CHECK:  %Y = zext i8 %B to i32
 ; CHECK:  %phi = phi i32 [ %X, %bb ], [ %Y, %cont ], [ %Y, %cont2 ]
 
 
 declare void @g(i32)

llvm/trunk/test/Transforms/LoopStrengthReduce/funclet.ll

 
 throw:                                            ; preds = %throw, %entry
   %tmp96 = getelementptr inbounds i8, i8* undef, i32 1
   invoke void @reserve()
           to label %throw unwind label %pad
 
 pad:                                              ; preds = %throw
   %phi2 = phi i8* [ %tmp96, %throw ]
-  terminatepad [] unwind label %blah
+  terminatepad within none [] unwind label %blah
 
 blah:
-  catchpad [] to label %unreachable unwind label %blah3
+  %cs = catchswitch within none [label %unreachable] unwind label %blah2
 
 unreachable:
+  catchpad within %cs []
   unreachable
 
-blah3:
-  catchendpad unwind label %blah2
-
 blah2:
-  %cleanuppadi4.i.i.i = cleanuppad []
+  %cleanuppadi4.i.i.i = cleanuppad within none []
   br label %loop_body
 
 loop_body:                                        ; preds = %iter, %pad
   %tmp99 = phi i8* [ %tmp101, %iter ], [ %phi2, %blah2 ]
   %tmp100 = icmp eq i8* %tmp99, undef
   br i1 %tmp100, label %unwind_out, label %iter
 
 iter:                                             ; preds = %loop_body
   %tmp101 = getelementptr inbounds i8, i8* %tmp99, i32 1
   br i1 undef, label %unwind_out, label %loop_body
 
 unwind_out:                                       ; preds = %iter, %loop_body
-  cleanupret %cleanuppadi4.i.i.i unwind to caller
+  cleanupret from %cleanuppadi4.i.i.i unwind to caller
 }
 
 ; CHECK-LABEL: define void @f(
-; CHECK: cleanuppad []
+; CHECK: cleanuppad within none []
 ; CHECK-NEXT: ptrtoint i8* %phi2 to i32
 
 define void @g() personality i32 (...)* @_except_handler3 {
 entry:
   br label %throw
 
 throw:                                            ; preds = %throw, %entry
   %tmp96 = getelementptr inbounds i8, i8* undef, i32 1
   invoke void @reserve()
           to label %throw unwind label %pad
 
 pad:
   %phi2 = phi i8* [ %tmp96, %throw ]
-  catchpad [] to label %unreachable unwind label %blah
+  %cs = catchswitch within none [label %unreachable, label %blah] unwind to caller
 
 unreachable:
+  catchpad within %cs []
   unreachable
 
 blah:
-  %catchpad = catchpad [] to label %loop_body unwind label %blah3
-
-
-blah3:
-  catchendpad unwind to caller ;label %blah2
+  %catchpad = catchpad within %cs []
+  br label %loop_body
 
 unwind_out:
-  catchret %catchpad to label %leave
+  catchret from %catchpad to label %leave
 
 leave:
   ret void
 
 loop_body:                                        ; preds = %iter, %pad
   %tmp99 = phi i8* [ %tmp101, %iter ], [ %phi2, %blah ]
   %tmp100 = icmp eq i8* %tmp99, undef
   br i1 %tmp100, label %unwind_out, label %iter
 
 iter:                                             ; preds = %loop_body
   %tmp101 = getelementptr inbounds i8, i8* %tmp99, i32 1
   br i1 undef, label %unwind_out, label %loop_body
 }
 
 ; CHECK-LABEL: define void @g(
 ; CHECK: blah:
-; CHECK-NEXT: catchpad []
-; CHECK-NEXT: to label %loop_body.preheader
-
-; CHECK: loop_body.preheader:
+; CHECK-NEXT: catchpad within %cs []
 ; CHECK-NEXT: ptrtoint i8* %phi2 to i32
 
 
 define void @h() personality i32 (...)* @_except_handler3 {
 entry:
   br label %throw
 
 throw:                                            ; preds = %throw, %entry
   %tmp96 = getelementptr inbounds i8, i8* undef, i32 1
   invoke void @reserve()
           to label %throw unwind label %pad
 
 pad:
-  catchpad [] to label %unreachable unwind label %blug
+  %cs = catchswitch within none [label %unreachable, label %blug] unwind to caller
 
 unreachable:
+  catchpad within %cs []
   unreachable
 
 blug:
   %phi2 = phi i8* [ %tmp96, %pad ]
-  %catchpad = catchpad [] to label %blah2 unwind label %blah3
-
-blah2:
+  %catchpad = catchpad within %cs []
   br label %loop_body
 
-blah3:
-  catchendpad unwind to caller ;label %blah2
-
 unwind_out:
-  catchret %catchpad to label %leave
+  catchret from %catchpad to label %leave
 
 leave:
   ret void
 
 loop_body:                                        ; preds = %iter, %pad
-  %tmp99 = phi i8* [ %tmp101, %iter ], [ %phi2, %blah2 ]
+  %tmp99 = phi i8* [ %tmp101, %iter ], [ %phi2, %blug ]
   %tmp100 = icmp eq i8* %tmp99, undef
   br i1 %tmp100, label %unwind_out, label %iter
 
 iter:                                             ; preds = %loop_body
   %tmp101 = getelementptr inbounds i8, i8* %tmp99, i32 1
   br i1 undef, label %unwind_out, label %loop_body
 }
 
 ; CHECK-LABEL: define void @h(
 ; CHECK: blug:
-; CHECK: catchpad []
-; CHECK-NEXT: to label %blah2
-
-; CHECK: blah2:
+; CHECK: catchpad within %cs []
 ; CHECK-NEXT: ptrtoint i8* %phi2 to i32
 
 define void @i() personality i32 (...)* @_except_handler3 {
 entry:
   br label %throw
 
 throw:                                            ; preds = %throw, %entry
   %tmp96 = getelementptr inbounds i8, i8* undef, i32 1
   invoke void @reserve()
           to label %throw unwind label %catchpad
 
 catchpad:                                              ; preds = %throw
   %phi2 = phi i8* [ %tmp96, %throw ]
-  catchpad [] to label %cp_body unwind label %catchendpad
+  %cs = catchswitch within none [label %cp_body] unwind label %cleanuppad
 
 cp_body:
+  catchpad within %cs []
   br label %loop_head
 
-catchendpad:
-  catchendpad unwind label %cleanuppad
-
 cleanuppad:
-  cleanuppad []
+  cleanuppad within none []
   br label %loop_head
 
 loop_head:
   br label %loop_body
 
 loop_body:                                        ; preds = %iter, %catchpad
   %tmp99 = phi i8* [ %tmp101, %iter ], [ %phi2, %loop_head ]
   %tmp100 = icmp eq i8* %tmp99, undef
for.cond:                                         ; preds = %for.inc, %entry
   invoke void @external(i32* %d.0)
           to label %for.inc unwind label %catch.dispatch
 
 for.inc:                                          ; preds = %for.cond
   %incdec.ptr = getelementptr inbounds i32, i32* %d.0, i32 1
   br label %for.cond
 
 catch.dispatch:                                   ; preds = %for.cond
-  %0 = catchpad [i8* null, i32 64, i8* null]
-          to label %catch unwind label %catchendblock
-
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind label %catch.dispatch.2
+  %cs = catchswitch within none [label %catch] unwind label %catch.dispatch.2
 
 catch:                                            ; preds = %catch.dispatch
-  catchret %0 to label %try.cont
+  %0 = catchpad within %cs [i8* null, i32 64, i8* null]
+  catchret from %0 to label %try.cont
 
 try.cont:                                         ; preds = %catch
   invoke void @external(i32* %c)
           to label %try.cont.7 unwind label %catch.dispatch.2
 
 catch.dispatch.2:                                 ; preds = %try.cont, %catchendblock
-  %e.0 = phi i32* [ %c, %try.cont ], [ %b, %catchendblock ]
-  %1 = catchpad [i8* null, i32 64, i8* null]
-          to label %catch.4 unwind label %catchendblock.3
+  %e.0 = phi i32* [ %c, %try.cont ], [ %b, %catch.dispatch ]
+  %cs2 = catchswitch within none [label %catch.4] unwind to caller
 
 catch.4:                                          ; preds = %catch.dispatch.2
+  catchpad within %cs2 [i8* null, i32 64, i8* null]
   unreachable
 
 try.cont.7:                                       ; preds = %try.cont
   ret void
-
-catchendblock.3:                                  ; preds = %catch.dispatch.2
-  catchendpad unwind to caller
 }
 
 ; CHECK-LABEL: define void @test1(
 ; CHECK: for.cond:
 ; CHECK:   %d.0 = phi i32* [ %b, %entry ], [ %incdec.ptr, %for.inc ]
 
-; CHECK: catchendpad unwind label %catch.dispatch.2
-
 ; CHECK: catch.dispatch.2:
-; CHECK: %e.0 = phi i32* [ %c, %try.cont ], [ %b, %catchendblock ]
+; CHECK: %e.0 = phi i32* [ %c, %try.cont ], [ %b, %catch.dispatch ]

llvm/trunk/test/Transforms/LoopStrengthReduce/pr25541.ll

 ; RUN: opt < %s -loop-reduce -S | FileCheck %s
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
 define void @f() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   br label %for.cond.i
 
 for.cond.i:                                       ; preds = %for.inc.i, %entry
   %_First.addr.0.i = phi i32* [ null, %entry ], [ %incdec.ptr.i, %for.inc.i ]
   invoke void @g()
           to label %for.inc.i unwind label %catch.dispatch.i
 
 catch.dispatch.i:                                 ; preds = %for.cond.i
-  %0 = catchpad [i8* null, i32 64, i8* null]
-          to label %for.cond.1.preheader.i unwind label %catchendblock.i
+  %cs = catchswitch within none [label %for.cond.1.preheader.i] unwind to caller
 
 for.cond.1.preheader.i:                           ; preds = %catch.dispatch.i
+  %0 = catchpad within %cs [i8* null, i32 64, i8* null]
   %cmp.i = icmp eq i32* %_First.addr.0.i, null
   br label %for.cond.1.i
 
 for.cond.1.i:                                     ; preds = %for.body.i, %for.cond.1.preheader.i
   br i1 %cmp.i, label %for.end.i, label %for.body.i
 
 for.body.i:                                       ; preds = %for.cond.1.i
-  invoke void @g()
-          to label %for.cond.1.i unwind label %catchendblock.i
-
-catchendblock.i:                                  ; preds = %for.body.i, %catch.dispatch.i
-  catchendpad unwind to caller
+  call void @g()
+  br label %for.cond.1.i
 
 for.inc.i:                                        ; preds = %for.cond.i
   %incdec.ptr.i = getelementptr inbounds i32, i32* %_First.addr.0.i, i64 1
   br label %for.cond.i
 
 for.end.i:                                        ; preds = %for.cond.1.i
-  catchret %0 to label %leave
+  catchret from %0 to label %leave
 
 leave:                                            ; preds = %for.end.i
   ret void
 }
 
 ; CHECK-LABEL: define void @f(
 ; CHECK: %[[PHI:.*]]  = phi i64 [ %[[IV_NEXT:.*]], {{.*}} ], [ 0, {{.*}} ]
 ; CHECK: %[[ITOP:.*]] = inttoptr i64 %[[PHI]] to i32*
 ; CHECK: %[[CMP:.*]]  = icmp eq i32* %[[ITOP]], null
 ; CHECK: %[[IV_NEXT]] = add i64 %[[PHI]], -4
 
 declare void @g()
 
 declare i32 @__CxxFrameHandler3(...)

llvm/trunk/test/Transforms/LoopUnswitch/cleanuppad.ll

+; RUN: opt -S -loop-unswitch < %s | FileCheck %s
+target triple = "x86_64-pc-win32"
+
+define void @f(i32 %doit, i1 %x, i1 %y) personality i32 (...)* @__CxxFrameHandler3 {
+entry:
+  %tobool = icmp eq i32 %doit, 0
+  br label %for.cond
+
+for.cond:                                         ; preds = %for.inc, %entry
+  br i1 %x, label %for.body, label %for.end
+
+for.body:                                         ; preds = %for.cond
+  br i1 %tobool, label %if.then, label %for.inc
+
+if.then:                                          ; preds = %for.body
+  br i1 %y, label %for.inc, label %delete.notnull
+
+delete.notnull:                                   ; preds = %if.then
+  invoke void @g()
+          to label %invoke.cont unwind label %lpad
+
+invoke.cont:                                      ; preds = %delete.notnull
+  br label %for.inc
+
+lpad:                                             ; preds = %delete.notnull
+  %cp = cleanuppad within none []
+  cleanupret from %cp unwind to caller
+
+for.inc:                                          ; preds = %invoke.cont, %if.then, %for.body
+  br label %for.cond
+
+for.end:                                          ; preds = %for.cond
+  ret void
+}
+
+declare void @g()
+
+declare i32 @__CxxFrameHandler3(...)
+
+; CHECK-LABEL: define void @f(
+; CHECK: cleanuppad within none []
+; CHECK-NOT: cleanuppad
+
+attributes #0 = { ssp uwtable }

llvm/trunk/test/Transforms/SimplifyCFG/empty-cleanuppad.ll

 define void @f1() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   invoke void @g() to label %invoke.cont unwind label %ehcleanup
 
 invoke.cont:                                      ; preds = %entry
   ret void
 
 ehcleanup:                                        ; preds = %entry
-  %0 = cleanuppad []
-  cleanupret %0 unwind label %ehcleanup.1
+  %0 = cleanuppad within none []
+  cleanupret from %0 unwind label %ehcleanup.1
 
 ehcleanup.1:                                      ; preds = %ehcleanup
-  %1 = cleanuppad []
-  cleanupret %1 unwind to caller
+  %1 = cleanuppad within none []
+  cleanupret from %1 unwind to caller
 }
 
 
 ; This case arises when an object with an empty destructor must be cleaned up
 ; outside of a try-block and an object with a non-empty destructor must be
 ; cleaned up within the try-block.
 ;
 ; void f2() { 
 ;   S a;
 ;   try {
 ;     S2 b;
 ;     g();
 ;   } catch (...) {}
 ; }
 ;
 ; In this case, the outermost cleanup pad can be eliminated and the catch block
 ; should unwind to the caller (that is, exception handling continues with the
 ; parent frame of the caller).
 ;
 ; CHECK: define void @f2()
 ; CHECK: entry:
 ; CHECK:   invoke void @g()
 ; CHECK: ehcleanup:
-; CHECK:   cleanuppad
+; CHECK:   cleanuppad within none
 ; CHECK:   call void @"\01??1S2@@QEAA@XZ"(%struct.S2* %b)
-; CHECK:   cleanupret %0 unwind label %catch.dispatch
+; CHECK:   cleanupret from %0 unwind label %catch.dispatch
 ; CHECK: catch.dispatch:
-; CHECK:   catchpad
+; CHECK:   catchswitch within none [label %catch] unwind to caller
 ; CHECK: catch:
+; CHECK:   catchpad
 ; CHECK:   catchret
-; CHECK: catchendblock:                                    ; preds = %catch.dispatch
-; CHECK:   catchendpad unwind to caller
 ; CHECK-NOT: cleanuppad
 ; CHECK: }
 ;
 define void @f2() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %b = alloca %struct.S2, align 1
   invoke void @g() to label %invoke.cont unwind label %ehcleanup
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont
 
 ehcleanup:                                        ; preds = %entry
-  %0 = cleanuppad []
+  %0 = cleanuppad within none []
   call void @"\01??1S2@@QEAA@XZ"(%struct.S2* %b)
-  cleanupret %0 unwind label %catch.dispatch
+  cleanupret from %0 unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %ehcleanup
-  %1 = catchpad [i8* null, i32 u0x40, i8* null] to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind label %ehcleanup.1
 
 catch:                                            ; preds = %catch.dispatch
-  catchret %1 to label %catchret.dest
+  %1 = catchpad within %cs1 [i8* null, i32 u0x40, i8* null]
+  catchret from %1 to label %catchret.dest
 
 catchret.dest:                                    ; preds = %catch
   br label %try.cont
 
 try.cont:                                         ; preds = %catchret.dest, %invoke.cont
   ret void
 
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind label %ehcleanup.1
-
-ehcleanup.1:                                      ; preds = %catchendblock
-  %2 = cleanuppad []
-  cleanupret %2 unwind to caller
+ehcleanup.1:
+  %2 = cleanuppad within none []
+  cleanupret from %2 unwind to caller
 }
 
 
 ; This case arises when an object with a non-empty destructor must be cleaned up
 ; outside of a try-block and an object with an empty destructor must be cleaned
 ; within the try-block.
 ;
 ; void f3() { 
 ;   S2 a;
 ;   try {
 ;     S b;
 ;     g();
 ;   } catch (...) {}
 ; }
 ;
 ; In this case the inner cleanup pad should be eliminated and the invoke of g()
 ; should unwind directly to the catchpad.
 ;
-; CHECK: define void @f3()
+; CHECK-LABEL: define void @f3()
 ; CHECK: entry:
 ; CHECK:   invoke void @g()
 ; CHECK:           to label %try.cont unwind label %catch.dispatch
 ; CHECK: catch.dispatch:
-; CHECK:   catchpad [i8* null, i32 64, i8* null]
-; CHECK-NEXT: to label %catch unwind label %catchendblock
+; CHECK-NEXT: catchswitch within none [label %catch] unwind label %ehcleanup.1
 ; CHECK: catch:
+; CHECK:   catchpad within %cs1 [i8* null, i32 64, i8* null]
 ; CHECK:   catchret
-; CHECK: catchendblock:
-; CHECK:   catchendpad unwind label %ehcleanup.1
 ; CHECK: ehcleanup.1:
 ; CHECK:   cleanuppad
 ; CHECK:   call void @"\01??1S2@@QEAA@XZ"(%struct.S2* %a)
-; CHECK:   cleanupret %1 unwind to caller
+; CHECK:   cleanupret from %cp3 unwind to caller
 ; CHECK: }
 ;
 define void @f3() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %a = alloca %struct.S2, align 1
   invoke void @g() to label %invoke.cont unwind label %ehcleanup
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont
 
 ehcleanup:                                        ; preds = %entry
-  %0 = cleanuppad []
-  cleanupret %0 unwind label %catch.dispatch
+  %0 = cleanuppad within none []
+  cleanupret from %0 unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %ehcleanup
-  %1 = catchpad [i8* null, i32 u0x40, i8* null] to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind label %ehcleanup.1
 
 catch:                                            ; preds = %catch.dispatch
-  catchret %1 to label %catchret.dest
+  %cp2 = catchpad within %cs1 [i8* null, i32 u0x40, i8* null]
+  catchret from %cp2 to label %catchret.dest
 
 catchret.dest:                                    ; preds = %catch
   br label %try.cont
 
 try.cont:                                         ; preds = %catchret.dest, %invoke.cont
   ret void
 
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind label %ehcleanup.1
-
-ehcleanup.1:                                      ; preds = %catchendblock
-  %2 = cleanuppad []
+ehcleanup.1:
+  %cp3 = cleanuppad within none []
   call void @"\01??1S2@@QEAA@XZ"(%struct.S2* %a)
-  cleanupret %2 unwind to caller
+  cleanupret from %cp3 unwind to caller
 }
 
 
 ; This case arises when an object with an empty destructor may require cleanup
 ; from either inside or outside of a try-block.
 ;
 ; void f4() { 
 ;   S a;
 ;   g();
 ;   try {
 ;     g();
 ;   } catch (...) {}
 ; }
 ;
 ; In this case, the cleanuppad should be eliminated, the invoke outside of the
-; call block should be converted to a call and the catchendpad should unwind
-; to the caller (that is, that is, exception handling continues with the parent
-; frame of the caller).)
+; catch block should be converted to a call (that is, that is, exception
+; handling continues with the parent frame of the caller).)
 ;
-; CHECK: define void @f4()
+; CHECK-LABEL: define void @f4()
 ; CHECK: entry:
 ; CHECK:   call void @g
 ; Note: The cleanuppad simplification will insert an unconditional branch here
 ;       but it will be eliminated, placing the following invoke in the entry BB. 
 ; CHECK:   invoke void @g()
 ; CHECK:           to label %try.cont unwind label %catch.dispatch
 ; CHECK: catch.dispatch:
-; CHECK:   catchpad
+; CHECK:   catchswitch within none [label %catch] unwind to caller
 ; CHECK: catch:
+; CHECK:   catchpad
 ; CHECK:   catchret
-; CHECK: catchendblock:
-; CHECK:   catchendpad unwind to caller
 ; CHECK-NOT: cleanuppad
 ; CHECK: }
 ;
 define void @f4() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   invoke void @g()
           to label %invoke.cont unwind label %ehcleanup
 
 invoke.cont:                                      ; preds = %entry
   invoke void @g()
           to label %try.cont unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %invoke.cont
-  %0 = catchpad [i8* null, i32 u0x40, i8* null] to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind label %ehcleanup
 
 catch:                                            ; preds = %catch.dispatch
-  catchret %0 to label %try.cont
+  %0 = catchpad within %cs1 [i8* null, i32 u0x40, i8* null]
+  catchret from %0 to label %try.cont
 
 try.cont:                                         ; preds = %catch, %invoke.cont
   ret void
 
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind label %ehcleanup
-
-ehcleanup:                                        ; preds = %catchendblock, %entry
-  %1 = cleanuppad []
-  cleanupret %1 unwind to caller
+ehcleanup:
+  %cp2 = cleanuppad within none []
+  cleanupret from %cp2 unwind to caller
 }
 
 ; This tests the case where a terminatepad unwinds to a cleanuppad.
 ; I'm not sure how this case would arise, but it seems to be syntactically
 ; legal so I'm testing it.
 ;
-; CHECK: define void @f5()
+; CHECK-LABEL: define void @f5()
 ; CHECK: entry:
 ; CHECK:   invoke void @g()
 ; CHECK:           to label %try.cont unwind label %terminate
 ; CHECK: terminate:
-; CHECK:   terminatepad [i7 4] unwind to caller
+; CHECK:   terminatepad within none [i7 4] unwind to caller
 ; CHECK-NOT: cleanuppad
 ; CHECK: try.cont:
 ; CHECK:   invoke void @g()
 ; CHECK:           to label %try.cont.1 unwind label %terminate.1
 ; CHECK: terminate.1:
-; CHECK:   terminatepad [i7 4] unwind label %ehcleanup.2
+; CHECK:   terminatepad within none [i7 4] unwind label %ehcleanup.2
 ; CHECK-NOT: ehcleanup.1:
 ; CHECK: ehcleanup.2:
 ; CHECK:   [[TMP:\%.+]] = cleanuppad
 ; CHECK:   call void @"\01??1S2@@QEAA@XZ"(%struct.S2* %a)
-; CHECK:   cleanupret [[TMP]] unwind to caller
+; CHECK:   cleanupret from [[TMP]] unwind to caller
 ; CHECK: }
 define void @f5() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %a = alloca %struct.S2, align 1
   invoke void @g()
           to label %try.cont unwind label %terminate
 
 terminate:                                        ; preds = %entry
-  terminatepad [i7 4] unwind label %ehcleanup
+  terminatepad within none [i7 4] unwind label %ehcleanup
 
 ehcleanup:                                        ; preds = %terminate
-  %0 = cleanuppad []
-  cleanupret %0 unwind to caller
+  %0 = cleanuppad within none []
+  cleanupret from %0 unwind to caller
 
 try.cont:                                         ; preds = %entry
   invoke void @g()
           to label %try.cont.1 unwind label %terminate.1
 
 terminate.1:                                      ; preds = %try.cont
-  terminatepad [i7 4] unwind label %ehcleanup.1
+  terminatepad within none [i7 4] unwind label %ehcleanup.1
 
 ehcleanup.1:                                      ; preds = %terminate.1
-  %1 = cleanuppad []
-  cleanupret %1 unwind label %ehcleanup.2
+  %1 = cleanuppad within none []
+  cleanupret from %1 unwind label %ehcleanup.2
 
 ehcleanup.2:                                      ; preds = %ehcleanup.1
-  %2 = cleanuppad []
+  %2 = cleanuppad within none []
   call void @"\01??1S2@@QEAA@XZ"(%struct.S2* %a)
-  cleanupret %2 unwind to caller
+  cleanupret from %2 unwind to caller
 
 try.cont.1:                                       ; preds = %try.cont
   ret void
 }
 
 ; This case tests simplification of an otherwise empty cleanup pad that contains
 ; a PHI node.
 ;
 ; int f6() {
 ;   int state = 1;
 ;   try {
 ;     S a;
 ;     g();
 ;     state = 2;
 ;     g();
 ;   } catch (...) {
 ;     return state;
 ;   }
 ;   return 0;
 ; }
 ;
 ; In this case, the cleanup pad should be eliminated and the PHI node in the
 ; cleanup pad should be sunk into the catch dispatch block.
 ;
-; CHECK: define i32 @f6()
+; CHECK-LABEL: define i32 @f6()
 ; CHECK: entry:
 ; CHECK:   invoke void @g()
 ; CHECK: invoke.cont:
 ; CHECK:   invoke void @g()
 ; CHECK-NOT: ehcleanup:
 ; CHECK-NOT:   cleanuppad
 ; CHECK: catch.dispatch:
 ; CHECK:   %state.0 = phi i32 [ 2, %invoke.cont ], [ 1, %entry ]
 ; CHECK: }
 define i32 @f6() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   invoke void @g()
           to label %invoke.cont unwind label %ehcleanup
 
 invoke.cont:                                      ; preds = %entry
   invoke void @g()
           to label %return unwind label %ehcleanup
 
 ehcleanup:                                        ; preds = %invoke.cont, %entry
   %state.0 = phi i32 [ 2, %invoke.cont ], [ 1, %entry ]
-  %0 = cleanuppad []
-  cleanupret %0 unwind label %catch.dispatch
+  %0 = cleanuppad within none []
+  cleanupret from %0 unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %ehcleanup
-  %1 = catchpad [i8* null, i32 u0x40, i8* null] to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:                                            ; preds = %catch.dispatch
-  catchret %1 to label %return
-
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind to caller
+  %1 = catchpad within %cs1 [i8* null, i32 u0x40, i8* null]
+  catchret from %1 to label %return
 
 return:                                           ; preds = %invoke.cont, %catch
   %retval.0 = phi i32 [ %state.0, %catch ], [ 0, %invoke.cont ]
   ret i32 %retval.0
 }
 
 ; This case tests another variation of simplification of an otherwise empty
 ; cleanup pad that contains a PHI node.

 ;     return state;
 ;   }
 ;   return 0;
 ; }
 ;
 ; In this case, the cleanup pad should be eliminated and the PHI node in the
 ; cleanup pad should be merged with the PHI node in the catch dispatch block.
 ;
-; CHECK: define i32 @f7()
+; CHECK-LABEL: define i32 @f7()
 ; CHECK: entry:
 ; CHECK:   invoke void @g()
 ; CHECK: invoke.cont:
 ; CHECK:   invoke void @g()
 ; CHECK: invoke.cont.1:
 ; CHECK:   invoke void @g()
 ; CHECK-NOT: ehcleanup:
 ; CHECK-NOT:   cleanuppad
invoke void @g()
           to label %invoke.cont.1 unwind label %ehcleanup
 
 invoke.cont.1:                                    ; preds = %invoke.cont
   invoke void @g()
           to label %return unwind label %ehcleanup
 
 ehcleanup:                                        ; preds = %invoke.cont.1, %invoke.cont
   %state.0 = phi i32 [ 3, %invoke.cont.1 ], [ 2, %invoke.cont ]
-  %0 = cleanuppad []
-  cleanupret %0 unwind label %catch.dispatch
+  %0 = cleanuppad within none []
+  cleanupret from %0 unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %ehcleanup, %entry
   %state.1 = phi i32 [ %state.0, %ehcleanup ], [ 1, %entry ]
-  %1 = catchpad [i8* null, i32 u0x40, i8* null] to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:                                            ; preds = %catch.dispatch
-  catchret %1 to label %return
-
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind to caller
+  %1 = catchpad within %cs1 [i8* null, i32 u0x40, i8* null]
+  catchret from %1 to label %return
 
 return:                                           ; preds = %invoke.cont.1, %catch
   %retval.0 = phi i32 [ %state.1, %catch ], [ 0, %invoke.cont.1 ]
   ret i32 %retval.0
 }
 
 ; This case tests a scenario where an empty cleanup pad is not dominated by all
 ; of the predecessors of its successor, but the successor references a PHI node

 ; }
 ;
 ; While that C++ syntax isn't legal, the IR below is.
 ;
 ; In this case, the PHI node that is sunk from ehcleanup to catch.dispatch
 ; should have an incoming value entry for path from 'foo' that references the
 ; PHI node itself.
 ;
-; CHECK: define void @f8()
+; CHECK-LABEL: define void @f8()
 ; CHECK: entry:
 ; CHECK:   invoke void @g()
 ; CHECK: invoke.cont:
 ; CHECK:   invoke void @g()
 ; CHECK-NOT: ehcleanup:
 ; CHECK-NOT:   cleanuppad
 ; CHECK: catch.dispatch:
 ; CHECK:   %x = phi i32 [ 2, %invoke.cont ], [ 1, %entry ], [ %x, %catch.cont ] 
 ; CHECK: }
 define void @f8() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   invoke void @g()
           to label %invoke.cont unwind label %ehcleanup
 
 invoke.cont:                                      ; preds = %entry
   invoke void @g()
           to label %return unwind label %ehcleanup
 
 ehcleanup:                                        ; preds = %invoke.cont, %entry
   %x = phi i32 [ 2, %invoke.cont ], [ 1, %entry ]
-  %0 = cleanuppad []
-  cleanupret %0 unwind label %catch.dispatch
+  %0 = cleanuppad within none []
+  cleanupret from %0 unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %ehcleanup, %catch.cont
-  %1 = catchpad [i8* null, i32 u0x40, i8* null] to label %catch unwind label %catchendblock
+  %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:                                            ; preds = %catch.dispatch
+  %1 = catchpad within %cs1 [i8* null, i32 u0x40, i8* null]
   call void @use_x(i32 %x)
-  catchret %1 to label %catch.cont
-
-catchendblock:                                    ; preds = %catch.dispatch
-  catchendpad unwind to caller
+  catchret from %1 to label %catch.cont
 
 catch.cont:                                       ; preds = %catch
   invoke void @g()
           to label %return unwind label %catch.dispatch
 
 return:                                           ; preds = %invoke.cont, %catch.cont
   ret void
 }

llvm/trunk/test/Transforms/SimplifyCFG/wineh-unreachable.ll

 ; RUN: opt -S -simplifycfg < %s | FileCheck %s
 
 declare void @Personality()
 declare void @f()
 
 ; CHECK-LABEL: define void @test1()
 define void @test1() personality i8* bitcast (void ()* @Personality to i8*) {
 entry:
   ; CHECK: call void @f()
   invoke void @f()
     to label %exit unwind label %unreachable.unwind
 exit:
   ret void
 unreachable.unwind:
-  cleanuppad []
+  cleanuppad within none []
   unreachable  
 }
 
 ; CHECK-LABEL: define void @test2()
 define void @test2() personality i8* bitcast (void ()* @Personality to i8*) {
 entry:
   invoke void @f()
     to label %exit unwind label %catch.pad
 catch.pad:
-  ; CHECK: catchpad []
-  ; CHECK-NEXT: to label %catch.body unwind label %catch.end
-  %catch = catchpad []
-    to label %catch.body unwind label %catch.end
+  %cs1 = catchswitch within none [label %catch.body] unwind label %unreachable.unwind
+  ; CHECK: catch.pad:
+  ; CHECK-NEXT: catchswitch within none [label %catch.body] unwind to caller
 catch.body:
   ; CHECK:      catch.body:
+  ; CHECK-NEXT:   catchpad within %cs1
   ; CHECK-NEXT:   call void @f()
   ; CHECK-NEXT:   unreachable
+  %catch = catchpad within %cs1 []
   call void @f()
-  catchret %catch to label %unreachable
-catch.end:
-  ; CHECK: catch.end:
-  ; CHECK-NEXT: catchendpad unwind to caller
-  catchendpad unwind label %unreachable.unwind
+  catchret from %catch to label %unreachable
 exit:
   ret void
 unreachable.unwind:
-  cleanuppad []
+  cleanuppad within none []
   unreachable
 unreachable:
   unreachable
 }
 
 ; CHECK-LABEL: define void @test3()
 define void @test3() personality i8* bitcast (void ()* @Personality to i8*) {
 entry:
   invoke void @f()
     to label %exit unwind label %cleanup.pad
 cleanup.pad:
-  ; CHECK: %cleanup = cleanuppad []
+  ; CHECK: %cleanup = cleanuppad within none []
   ; CHECK-NEXT: call void @f()
   ; CHECK-NEXT: unreachable
-  %cleanup = cleanuppad []
+  %cleanup = cleanuppad within none []
   invoke void @f()
-    to label %cleanup.ret unwind label %cleanup.end
+    to label %cleanup.ret unwind label %unreachable.unwind
 cleanup.ret:
   ; This cleanupret should be rewritten to unreachable,
   ; and merged into the pred block.
-  cleanupret %cleanup unwind label %unreachable.unwind
-cleanup.end:
-  ; This cleanupendpad should be rewritten to unreachable,
-  ; causing the invoke to be rewritten to a call.
-  cleanupendpad %cleanup unwind label %unreachable.unwind
+  cleanupret from %cleanup unwind label %unreachable.unwind
 exit:
   ret void
 unreachable.unwind:
-  cleanuppad []
+  cleanuppad within none []
   unreachable
 }
 
 ; CHECK-LABEL: define void @test4()
 define void @test4() personality i8* bitcast (void ()* @Personality to i8*) {
 entry:
   invoke void @f()
     to label %exit unwind label %terminate.pad
 terminate.pad:
-  ; CHECK: terminatepad [] unwind to caller
-  terminatepad [] unwind label %unreachable.unwind
+  ; CHECK: terminatepad within none [] unwind to caller
+  terminatepad within none [] unwind label %unreachable.unwind
 exit:
   ret void
 unreachable.unwind:
-  cleanuppad []
+  cleanuppad within none []
   unreachable
 }
 
 ; CHECK-LABEL: define void @test5()
 define void @test5() personality i8* bitcast (void ()* @Personality to i8*) {
 entry:
   invoke void @f()
           to label %exit unwind label %catch.pad
 
 catch.pad:
-  %catch = catchpad []
-          to label %catch.body unwind label %catch.end
+  %cs1 = catchswitch within none [label %catch.body] unwind to caller
 
 catch.body:
-  catchret %catch to label %exit
-
-catch.end:
-  catchendpad unwind to caller
+  %catch = catchpad within %cs1 []
+  catchret from %catch to label %exit
 
 exit:
   unreachable
 }

llvm/trunk/test/Transforms/Sink/catchswitch.ll

+; RUN: opt -sink -S < %s | FileCheck %s
+
+target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
+target triple = "i686-pc-windows-msvc"
+
+define void @h() personality i32 (...)* @__CxxFrameHandler3 {
+entry:
+  %call = call i32 @g(i32 1) readnone
+  invoke void @_CxxThrowException(i8* null, i8* null) noreturn
+          to label %unreachable unwind label %catch.dispatch
+
+catch.dispatch:                                   ; preds = %entry
+  %cs = catchswitch within none [label %catch] unwind to caller
+
+catch:                                            ; preds = %catch.dispatch
+  %cp = catchpad within %cs [i8* null, i32 64, i8* null]
+  catchret from %cp to label %try.cont
+
+try.cont:                                         ; preds = %catch
+  call void @k(i32 %call)
+  ret void
+
+unreachable:                                      ; preds = %entry
+  unreachable
+}
+
+declare x86_stdcallcc void @_CxxThrowException(i8*, i8*)
+
+declare i32 @__CxxFrameHandler3(...)
+
+declare i32 @g(i32) readnone
+
+declare void @k(i32)
+
+; CHECK-LABEL: define void @h(
+; CHECK: call i32 @g(i32 1)
+; CHECK-NEXT: invoke void @_CxxThrowException(

llvm/trunk/test/Verifier/invalid-eh.ll

+; RUN: sed -e s/.T1:// %s | not llvm-as -disable-output 2>&1 | FileCheck --check-prefix=CHECK1 %s
+; RUN: sed -e s/.T2:// %s | not llvm-as -disable-output 2>&1 | FileCheck --check-prefix=CHECK2 %s
+; RUN: sed -e s/.T3:// %s | not llvm-as -disable-output 2>&1 | FileCheck --check-prefix=CHECK3 %s
+; RUN: sed -e s/.T4:// %s | not llvm-as -disable-output 2>&1 | FileCheck --check-prefix=CHECK4 %s
+
+;T1: define void @f() {
+;T1:   entry:
+;T1:     catchret from undef to label %next
+;T1:     ; CHECK1: CatchReturnInst needs to be provided a CatchPad
+;T1:   next:
+;T1:     unreachable
+;T1: }
+
+;T2: define void @f() {
+;T2:   entry:
+;T2:     %x = cleanuppad within none []
+;T2:     ; catchret's first operand's operator must be catchpad
+;T2:     catchret from %x to label %entry
+;T2:     ; CHECK2: CatchReturnInst needs to be provided a CatchPad
+;T2: }
+
+;T3: define void @f() {
+;T3:   entry:
+;T3:     cleanupret from undef unwind label %next
+;T3:     ; CHECK3: CleanupReturnInst needs to be provided a CleanupPad
+;T3:   next:
+;T3:     unreachable
+;T3: }
+
+;T4: define void @f() {
+;T4:   entry:
+;T4:     %cs = catchswitch within none [label %next] unwind to caller
+;T4:   next:
+;T4:     %x = catchpad within %cs []
+;T4:     ; cleanupret first operand's operator must be cleanuppad
+;T4:     cleanupret from %x unwind to caller
+;T4:     ; CHECK4: CleanupReturnInst needs to be provided a CleanupPad
+;T4: }

llvm/trunk/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

default: return nullptr;
       STRINGIFY_CODE(FUNC_CODE, INST_RET)
       STRINGIFY_CODE(FUNC_CODE, INST_BR)
       STRINGIFY_CODE(FUNC_CODE, INST_SWITCH)
       STRINGIFY_CODE(FUNC_CODE, INST_INVOKE)
       STRINGIFY_CODE(FUNC_CODE, INST_UNREACHABLE)
       STRINGIFY_CODE(FUNC_CODE, INST_CLEANUPRET)
       STRINGIFY_CODE(FUNC_CODE, INST_CATCHRET)
       STRINGIFY_CODE(FUNC_CODE, INST_CATCHPAD)
-      STRINGIFY_CODE(FUNC_CODE, INST_CLEANUPENDPAD)
-      STRINGIFY_CODE(FUNC_CODE, INST_CATCHENDPAD)
       STRINGIFY_CODE(FUNC_CODE, INST_TERMINATEPAD)
       STRINGIFY_CODE(FUNC_CODE, INST_PHI)
       STRINGIFY_CODE(FUNC_CODE, INST_ALLOCA)
       STRINGIFY_CODE(FUNC_CODE, INST_LOAD)
       STRINGIFY_CODE(FUNC_CODE, INST_VAARG)
       STRINGIFY_CODE(FUNC_CODE, INST_STORE)
       STRINGIFY_CODE(FUNC_CODE, INST_EXTRACTVAL)
       STRINGIFY_CODE(FUNC_CODE, INST_INSERTVAL)