diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DebugUIMessages.java b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DebugUIMessages.java
index 628eec6..18f6620 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DebugUIMessages.java
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DebugUIMessages.java
@@ -179,6 +179,7 @@
 	public static String thread_suspended_linebreakpoint;
 	public static String thread_suspended_methodentry;
 	public static String thread_suspended_exception;
+	public static String thread_suspended_exception_uncaught;
 	public static String thread_suspended_methodexit;
 	public static String thread_suspended_fieldmodification;
 	public static String thread_suspended_runtoline;
@@ -311,7 +312,15 @@
 	public static String JavaDebugOptionsManager_Method_breakpoint___2;
 	public static String JavaDebugOptionsManager_Watchpoint___3;
 	public static String JavaDebugOptionsManager_0;
+
+	public static String JavaDebugOptionsManager_exceptionRecurrence_dialogTitle;
+	public static String JavaDebugOptionsManager_exceptionRecurrence_dialogMessage;
+	public static String JavaDebugOptionsManager_cancel_buttonLabel;
+	public static String JavaDebugOptionsManager_skip_buttonLabel;
+	public static String JavaDebugOptionsManager_suspend_buttonLabel;
+
 	public static String JavaDebugOptionsManager_Line_breakpoint___4;
+
 	public static String JavaBreakpointWorkbenchAdapterFactory_1;
 
 	public static String HotCodeReplaceErrorDialog_0;
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DebugUIMessages.properties b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DebugUIMessages.properties
index 861d79c..03b9ef4 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DebugUIMessages.properties
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DebugUIMessages.properties
@@ -128,6 +128,7 @@
 thread_suspended_linebreakpoint=Thread [{0}] (Suspended (breakpoint at line {1} in {2}))
 thread_suspended_methodentry=Thread [{0}] (Suspended (entry into method {1} in {2}))
 thread_suspended_exception=Thread [{0}] (Suspended (exception {1}))
+thread_suspended_exception_uncaught=Thread [{0}] (Suspended (uncaught exception {1}))
 thread_suspended_methodexit=Thread [{0}] (Suspended (exit of method {1} in {2}))
 thread_suspended_fieldmodification=Thread [{0}] (Suspended (modification of field {1} in {2}))
 thread_suspended_runtoline=Thread [{0}] (Suspended (run to line {1} in {2}))
@@ -267,7 +268,20 @@
 JavaDebugOptionsManager_Method_breakpoint___2=Method breakpoint:
 JavaDebugOptionsManager_Watchpoint___3=Watchpoint:
 JavaDebugOptionsManager_0=Initialize Java Debug Options
+JavaDebugOptionsManager_exceptionRecurrence_dialogTitle=Repeated exception occurrence
+JavaDebugOptionsManager_exceptionRecurrence_dialogMessage=The debugger is about to suspend on the exception breakpoint for {0}, \
+but the current exception instance has already caused suspending before.\n\
+\n\
+Please choose how this breakpoint should react to repeated occurrences of the same exception instance:\n\
+ \u2022 Skip:\t\t fire only once per exception instance\n\
+ \u2022 Suspend:\t fire always\n\
+ \u2022 Cancel:\t suspend now, but don't remember this decision\n\n\
+This choice does not affect the global preference regarding uncaught exceptions. 
 JavaDebugOptionsManager_Line_breakpoint___4=Line breakpoint:
+JavaDebugOptionsManager_skip_buttonLabel=Skip
+JavaDebugOptionsManager_suspend_buttonLabel=Suspend
+JavaDebugOptionsManager_cancel_buttonLabel=Cancel
+
 JavaBreakpointWorkbenchAdapterFactory_1=\ [line:
 
 HotCodeReplaceErrorDialog_0=&Continue
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JDIModelPresentation.java b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JDIModelPresentation.java
index f243689..49f06cf 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JDIModelPresentation.java
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JDIModelPresentation.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2017 IBM Corporation and others.
+ * Copyright (c) 2000, 2019 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -77,6 +77,7 @@
 import org.eclipse.jdt.internal.debug.core.model.JDIReferenceListValue;
 import org.eclipse.jdt.internal.debug.core.model.JDIReferenceListVariable;
 import org.eclipse.jdt.internal.debug.core.model.JDIThread;
+import org.eclipse.jdt.internal.debug.ui.breakpoints.SuspendOnUncaughtExceptionListener;
 import org.eclipse.jdt.internal.debug.ui.display.JavaInspectExpression;
 import org.eclipse.jdt.internal.debug.ui.monitors.JavaContendedMonitor;
 import org.eclipse.jdt.internal.debug.ui.monitors.JavaOwnedMonitor;
@@ -368,6 +369,9 @@
 				// check args == null in case the exception is a compilation error
 				if (breakpoint instanceof IJavaExceptionBreakpoint && args == null) {
 					key.append("_exception"); //$NON-NLS-1$
+					if (isUncaughtExceptionsBreakpoint(breakpoint)) {
+						key.append("_uncaught"); //$NON-NLS-1$
+					}
 					String exName = ((IJavaExceptionBreakpoint)breakpoint).getExceptionTypeName();
 					if (exName == null) {
 						exName = typeName;
@@ -432,6 +436,19 @@
 		return DebugUIMessages.JDIModelPresentation_unknown_name__1;
 	}
 
+	private boolean isUncaughtExceptionsBreakpoint(IJavaBreakpoint breakpoint) {
+		try {
+			for (String id : breakpoint.getBreakpointListeners()) {
+				if (SuspendOnUncaughtExceptionListener.ID_UNCAUGHT_EXCEPTION_LISTENER.equals(id)) {
+					return true;
+				}
+			}
+		} catch (CoreException e) {
+			DebugUIPlugin.log(e);
+		}
+		return false;
+	}
+
 	/**
 	 * Build the text for an IJavaDebugTarget.
 	 */
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JavaDebugOptionsManager.java b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JavaDebugOptionsManager.java
index 93d63bf..541ee0c 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JavaDebugOptionsManager.java
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JavaDebugOptionsManager.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2015 IBM Corporation and others.
+ * Copyright (c) 2000, 2019 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -55,6 +55,7 @@
 import org.eclipse.jdt.debug.core.IJavaBreakpointListener;
 import org.eclipse.jdt.debug.core.IJavaDebugTarget;
 import org.eclipse.jdt.debug.core.IJavaExceptionBreakpoint;
+import org.eclipse.jdt.debug.core.IJavaExceptionBreakpoint.SuspendOnRecurrenceStrategy;
 import org.eclipse.jdt.debug.core.IJavaLineBreakpoint;
 import org.eclipse.jdt.debug.core.IJavaMethodBreakpoint;
 import org.eclipse.jdt.debug.core.IJavaMethodEntryBreakpoint;
@@ -67,10 +68,12 @@
 import org.eclipse.jdt.internal.debug.core.breakpoints.JavaExceptionBreakpoint;
 import org.eclipse.jdt.internal.debug.core.logicalstructures.IJavaStructuresListener;
 import org.eclipse.jdt.internal.debug.core.logicalstructures.JavaLogicalStructures;
+import org.eclipse.jdt.internal.debug.core.model.JDIThread;
 import org.eclipse.jdt.internal.debug.ui.actions.JavaBreakpointPropertiesAction;
 import org.eclipse.jdt.internal.debug.ui.breakpoints.SuspendOnCompilationErrorListener;
 import org.eclipse.jdt.internal.debug.ui.breakpoints.SuspendOnUncaughtExceptionListener;
 import org.eclipse.jdt.internal.debug.ui.snippeteditor.ScrapbookLauncher;
+import org.eclipse.jface.dialogs.MessageDialog;
 import org.eclipse.jface.preference.IPreferenceStore;
 import org.eclipse.jface.util.IPropertyChangeListener;
 import org.eclipse.jface.util.PropertyChangeEvent;
@@ -81,6 +84,7 @@
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.Shell;
 
+import com.ibm.icu.text.MessageFormat;
 import com.sun.jdi.InvocationException;
 import com.sun.jdi.ObjectReference;
 
@@ -567,10 +571,74 @@
 	 */
 	@Override
 	public int breakpointHit(IJavaThread thread, IJavaBreakpoint breakpoint) {
+		if (thread instanceof JDIThread && breakpoint instanceof IJavaExceptionBreakpoint) {
+			if (shouldSkipSubsequentOccurrence((JDIThread) thread, (IJavaExceptionBreakpoint) breakpoint)) {
+				return DONT_SUSPEND;
+			}
+		}
 		return DONT_CARE;
 	}
 
 	/**
+	 * Figure out whether suspending on an exceptionBreakpoint should be skipped due to the user's choice regarding
+	 * {@link IJavaExceptionBreakpoint#setSuspendOnRecurrenceStrategy(int)}.
+	 * <p>
+	 * If the current hit is indeed recurrence of an already-seen exception instance, and if the user has not yet made a choice for this breakpoint,
+	 * then a question dialog will be opened to request the user's choice.
+	 * </p>
+	 *
+	 * @param thread
+	 *            the thread where an exception occurred
+	 * @param exceptionBreakpoint
+	 *            the exceptionBreakpoint that just fired
+	 * @return {@code true} if the current breakpoint hit should be skipped.
+	 */
+	public boolean shouldSkipSubsequentOccurrence(JDIThread thread, IJavaExceptionBreakpoint exceptionBreakpoint) {
+		if (exceptionBreakpoint == fSuspendOnExceptionBreakpoint) {
+			// this breakpoint doesn't have the recurrence property, wait until we are called from SuspendOnUncaughtExceptionListener itself
+			return false;
+		}
+		SuspendOnRecurrenceStrategy skip = thread.shouldSkipExceptionRecurrence(exceptionBreakpoint);
+		if (skip == null) {
+			return false; // not a recurrence
+		}
+		if (skip == SuspendOnRecurrenceStrategy.RECURRENCE_UNCONFIGURED) {
+			skip = askUserExceptionRecurrence(exceptionBreakpoint);
+			try {
+				exceptionBreakpoint.setSuspendOnRecurrenceStrategy(skip);
+			} catch (CoreException e) {
+				JDIDebugUIPlugin.log(e);
+			}
+		}
+		switch (skip) {
+			case SKIP_RECURRENCES:
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	private static SuspendOnRecurrenceStrategy askUserExceptionRecurrence(IJavaExceptionBreakpoint breakpoint) {
+		Shell shell = JDIDebugUIPlugin.getShell();
+		MessageDialog question = new MessageDialog(shell, DebugUIMessages.JavaDebugOptionsManager_exceptionRecurrence_dialogTitle, null, //
+				MessageFormat.format(DebugUIMessages.JavaDebugOptionsManager_exceptionRecurrence_dialogMessage, breakpoint.getExceptionTypeName()), //
+				MessageDialog.QUESTION, 0, //
+				DebugUIMessages.JavaDebugOptionsManager_skip_buttonLabel, //
+				DebugUIMessages.JavaDebugOptionsManager_suspend_buttonLabel, //
+				DebugUIMessages.JavaDebugOptionsManager_cancel_buttonLabel);
+		int answer[] = { -1 };
+		shell.getDisplay().syncExec(() -> answer[0] = question.open());
+		switch (answer[0]) {
+			case 0:
+				return SuspendOnRecurrenceStrategy.SKIP_RECURRENCES;
+			case 1:
+				return SuspendOnRecurrenceStrategy.SUSPEND_ALWAYS;
+			default:
+				return SuspendOnRecurrenceStrategy.RECURRENCE_UNCONFIGURED;
+		}
+	}
+
+	/**
 	 * @see IJavaBreakpointListener#breakpointInstalled(IJavaDebugTarget, IJavaBreakpoint)
 	 */
 	@Override
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/breakpoints/ExceptionBreakpointEditor.java b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/breakpoints/ExceptionBreakpointEditor.java
index 8de056b..ccf78ee 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/breakpoints/ExceptionBreakpointEditor.java
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/breakpoints/ExceptionBreakpointEditor.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2009, 2011 IBM Corporation and others.
+ * Copyright (c) 2009, 2019 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -13,13 +13,23 @@
  *******************************************************************************/
 package org.eclipse.jdt.internal.debug.ui.breakpoints;
 
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.debug.internal.ui.SWTFactory;
 import org.eclipse.jdt.debug.core.IJavaBreakpoint;
 import org.eclipse.jdt.debug.core.IJavaExceptionBreakpoint;
+import org.eclipse.jdt.debug.core.IJavaExceptionBreakpoint.SuspendOnRecurrenceStrategy;
 import org.eclipse.jdt.internal.debug.core.breakpoints.JavaExceptionBreakpoint;
 import org.eclipse.jdt.internal.debug.ui.propertypages.PropertyPageMessages;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.layout.GridData;
 import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Combo;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Control;
 
@@ -34,11 +44,14 @@
     public static final int PROP_CAUGHT = 0x1020;
     public static final int PROP_UNCAUGHT = 0x1021;
     public static final int PROP_SUBCLASSES = 0x1022;
+	public static final int PROP_RECURRENCE = 0x1023;
 
 	// editors
 	private Button fCaught;
 	private Button fUncaught;
 	private Button fSubclasses;
+	private Combo fRecurrence;
+	private Map<SuspendOnRecurrenceStrategy, String> fRecurrenceOptions;
 
 	/* (non-Javadoc)
 	 * @see org.eclipse.jdt.internal.debug.ui.breakpoints.StandardJavaBreakpointEditor#createControl(org.eclipse.swt.widgets.Composite)
@@ -53,9 +66,27 @@
 		fCaught = createSusupendPropertyEditor(composite, processMnemonics(PropertyPageMessages.ExceptionBreakpointEditor_1), PROP_CAUGHT);
 		fUncaught = createSusupendPropertyEditor(composite, processMnemonics(PropertyPageMessages.ExceptionBreakpointEditor_2), PROP_UNCAUGHT);
 		fSubclasses = createSusupendPropertyEditor(composite, processMnemonics(PropertyPageMessages.ExceptionBreakpointEditor_3), PROP_SUBCLASSES);
+		composite = SWTFactory.createComposite(container, parent.getFont(), 2, 1, 0, 0, 0);
+		fRecurrence = createRecurrenceEditor(composite, processMnemonics(PropertyPageMessages.ExceptionBreakpointEditor_recurrence_label), PROP_RECURRENCE);
 		return container;
 	}
 
+	private Combo createRecurrenceEditor(Composite parent, String labelText, int propId) {
+		fRecurrenceOptions = new HashMap<>();
+		fRecurrenceOptions.put(SuspendOnRecurrenceStrategy.RECURRENCE_UNCONFIGURED, PropertyPageMessages.ExceptionBreakpointEditor_recurrence_unconfigured);
+		fRecurrenceOptions.put(SuspendOnRecurrenceStrategy.SUSPEND_ALWAYS, PropertyPageMessages.ExceptionBreakpointEditor_recurrence_always);
+		fRecurrenceOptions.put(SuspendOnRecurrenceStrategy.SKIP_RECURRENCES, PropertyPageMessages.ExceptionBreakpointEditor_recurrence_onlyOnce);
+		SWTFactory.createLabel(parent, labelText, 1);
+		Combo box = SWTFactory.createCombo(parent, SWT.READ_ONLY, 1, GridData.FILL_HORIZONTAL, fRecurrenceOptions.values().toArray(new String[fRecurrenceOptions.size()]));
+		box.addSelectionListener(new SelectionAdapter() {
+			@Override
+			public void widgetSelected(SelectionEvent e) {
+				setDirty(propId);
+			}
+		});
+		return box;
+	}
+
 	/* (non-Javadoc)
 	 * @see org.eclipse.jdt.internal.debug.ui.breakpoints.StandardJavaBreakpointEditor#setBreakpoint(org.eclipse.jdt.debug.core.IJavaBreakpoint)
 	 */
@@ -67,13 +98,16 @@
 			fCaught.setEnabled(true);
 			fUncaught.setEnabled(true);
 			fSubclasses.setEnabled(true);
+			fRecurrence.setEnabled(true);
 			fCaught.setSelection(ex.isCaught());
 			fUncaught.setSelection(ex.isUncaught());
 			fSubclasses.setSelection(((JavaExceptionBreakpoint)ex).isSuspendOnSubclasses());
+			fRecurrence.setText(fRecurrenceOptions.get(ex.getSuspendOnRecurrenceStrategy()));
 		} else {
 			fCaught.setEnabled(false);
 			fUncaught.setEnabled(false);
 			fSubclasses.setEnabled(false);
+			fRecurrence.setEnabled(false);
 		}
 	}
 
@@ -89,6 +123,16 @@
 			ex.setCaught(fCaught.getSelection());
 			ex.setUncaught(fUncaught.getSelection());
 			((JavaExceptionBreakpoint)ex).setSuspendOnSubclasses(fSubclasses.getSelection());
+			ex.setSuspendOnRecurrenceStrategy(stringToRecurrence(fRecurrence.getText()));
 		}
 	}
+
+	private SuspendOnRecurrenceStrategy stringToRecurrence(String text) {
+		for (Entry<SuspendOnRecurrenceStrategy, String> entry : fRecurrenceOptions.entrySet()) {
+			if (entry.getValue().equals(text)) {
+				return entry.getKey();
+			}
+		}
+		return SuspendOnRecurrenceStrategy.RECURRENCE_UNCONFIGURED;
+	}
 }
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/propertypages/PropertyPageMessages.java b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/propertypages/PropertyPageMessages.java
index 2c8c3b1..5f9e88f 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/propertypages/PropertyPageMessages.java
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/propertypages/PropertyPageMessages.java
@@ -23,6 +23,11 @@
 	public static String ExceptionBreakpointEditor_2;
 	public static String ExceptionBreakpointEditor_3;
 
+	public static String ExceptionBreakpointEditor_recurrence_label;
+	public static String ExceptionBreakpointEditor_recurrence_always;
+	public static String ExceptionBreakpointEditor_recurrence_onlyOnce;
+	public static String ExceptionBreakpointEditor_recurrence_unconfigured;
+
 	public static String ExceptionFilterEditor_5;
 	public static String ExceptionFilterEditor_6;
 	public static String ExceptionFilterEditor_7;
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/propertypages/PropertyPageMessages.properties b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/propertypages/PropertyPageMessages.properties
index 904b158..b3f1417 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/propertypages/PropertyPageMessages.properties
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/propertypages/PropertyPageMessages.properties
@@ -15,6 +15,10 @@
 ExceptionBreakpointEditor_1=&Caught locations
 ExceptionBreakpointEditor_2=&Uncaught locations
 ExceptionBreakpointEditor_3=Subclasses of this e&xception
+ExceptionBreakpointEditor_recurrence_label=Suspend on &recurrence per instance:
+ExceptionBreakpointEditor_recurrence_always=always
+ExceptionBreakpointEditor_recurrence_onlyOnce=only once
+ExceptionBreakpointEditor_recurrence_unconfigured=unconfigured
 ExceptionFilterEditor_5=Re&strict to Selected Location(s):\nChecked locations are inclusive (stop in the specified location)\nUnchecked locations are exclusive (do not stop in the specified location)
 ExceptionFilterEditor_6=&Add
 ExceptionFilterEditor_7=Add a fully qualified type name or package name expression as a filter pattern for this breakpoint
diff --git a/org.eclipse.jdt.debug/META-INF/MANIFEST.MF b/org.eclipse.jdt.debug/META-INF/MANIFEST.MF
index 6911b7a..dd3ebe3 100644
--- a/org.eclipse.jdt.debug/META-INF/MANIFEST.MF
+++ b/org.eclipse.jdt.debug/META-INF/MANIFEST.MF
@@ -2,7 +2,7 @@
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.jdt.debug; singleton:=true
-Bundle-Version: 3.13.200.qualifier
+Bundle-Version: 3.14.0.qualifier
 Bundle-ClassPath: jdi.jar,
  jdimodel.jar,
  tools.jar
diff --git a/org.eclipse.jdt.debug/model/org/eclipse/jdt/debug/core/IJavaExceptionBreakpoint.java b/org.eclipse.jdt.debug/model/org/eclipse/jdt/debug/core/IJavaExceptionBreakpoint.java
index fd11cf7..93c19c2 100644
--- a/org.eclipse.jdt.debug/model/org/eclipse/jdt/debug/core/IJavaExceptionBreakpoint.java
+++ b/org.eclipse.jdt.debug/model/org/eclipse/jdt/debug/core/IJavaExceptionBreakpoint.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2011 IBM Corporation and others.
+ * Copyright (c) 2000, 2019 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -196,4 +196,53 @@
 	 */
 	@Deprecated
 	public boolean isInclusiveFiltered() throws CoreException;
+
+	/**
+	 * Constants for telling the debugger for each exception breakpoint how to handle multiple occurrences of the same exception instance, which can
+	 * happen via re-throwing or multiple finally clauses in the call stack.
+	 *
+	 * @since 3.14
+	 * @see IJavaExceptionBreakpoint#getSuspendOnRecurrenceStrategy()
+	 * @see IJavaExceptionBreakpoint#setSuspendOnRecurrenceStrategy(SuspendOnRecurrenceStrategy)
+	 */
+	enum SuspendOnRecurrenceStrategy {
+		/**
+		 * Signals that this setting has not yet been configured for a given breakpoint
+		 */
+		RECURRENCE_UNCONFIGURED,
+		/**
+		 * Signals that the exception breakpoint should always cause suspending.
+		 */
+		SUSPEND_ALWAYS,
+		/**
+		 * Signals that the breakpoint should not cause suspending more than once. This does not influence the way how the debugger reacts to uncaught
+		 * exceptions.
+		 */
+		SKIP_RECURRENCES
+	}
+
+	/**
+	 * Define this breakpoint's {@link SuspendOnRecurrenceStrategy strategy} for suspending on recurrences of the same exception instance.
+	 *
+	 * @param strategy
+	 *            the new strategy
+	 *
+	 * @throws CoreException
+	 *             if accessing the breakpoint's marker failed
+	 * @since 3.14
+	 * @see #getSuspendOnRecurrenceStrategy()
+	 */
+	void setSuspendOnRecurrenceStrategy(SuspendOnRecurrenceStrategy strategy) throws CoreException;
+
+	/**
+	 * Answer this breakpoint's {@link SuspendOnRecurrenceStrategy strategy} for suspending on recurrences of the same exception instance.
+	 *
+	 * @return the strategy
+	 *
+	 * @throws CoreException
+	 *             if accessing the breakpoint's marker failed
+	 * @since 3.14
+	 * @see #setSuspendOnRecurrenceStrategy(SuspendOnRecurrenceStrategy)
+	 */
+	SuspendOnRecurrenceStrategy getSuspendOnRecurrenceStrategy() throws CoreException;
 }
diff --git a/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/breakpoints/JavaExceptionBreakpoint.java b/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/breakpoints/JavaExceptionBreakpoint.java
index bb2139e..9b1b622 100644
--- a/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/breakpoints/JavaExceptionBreakpoint.java
+++ b/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/breakpoints/JavaExceptionBreakpoint.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2017 IBM Corporation and others.
+ * Copyright (c) 2000, 2019 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -105,6 +105,14 @@
 	protected static final String SUSPEND_ON_SUBCLASSES = "org.eclipse.jdt.debug.core.suspend_on_subclasses"; //$NON-NLS-1$
 
 	/**
+	 * Allows the user to specify that each exception instance matching this breakpoint should suspend only once, i.e., re-throws and finally clauses
+	 * will not again suspend on an exception instance that had already caused a suspend.
+	 *
+	 * @since 3.14
+	 */
+	protected static final String SUSPEND_ON_RECURRENCE = "org.eclipse.jdt.debug.core.suspend_on_recurrence"; //$NON-NLS-1$
+
+	/**
 	 * Name of the exception that was actually hit (could be a sub-type of the
 	 * type that is being caught).
 	 */
@@ -322,6 +330,21 @@
 		recreate();
 	}
 
+	@Override
+	public SuspendOnRecurrenceStrategy getSuspendOnRecurrenceStrategy() throws CoreException {
+		int valueIndex = ensureMarker().getAttribute(SUSPEND_ON_RECURRENCE, SuspendOnRecurrenceStrategy.RECURRENCE_UNCONFIGURED.ordinal());
+		return SuspendOnRecurrenceStrategy.values()[valueIndex];
+	}
+
+	@Override
+	public void setSuspendOnRecurrenceStrategy(SuspendOnRecurrenceStrategy strategy) throws CoreException {
+		if (strategy == getSuspendOnRecurrenceStrategy()) {
+			return;
+		}
+		setAttribute(SUSPEND_ON_RECURRENCE, strategy.ordinal());
+		// don't re-create, the change only affects the debugger, not the target
+	}
+
 	/**
 	 * @see IJavaExceptionBreakpoint#isChecked()
 	 */
diff --git a/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/model/JDIThread.java b/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/model/JDIThread.java
index 45ee0ad..2e9a6a7 100644
--- a/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/model/JDIThread.java
+++ b/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/model/JDIThread.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2018 IBM Corporation and others.
+ * Copyright (c) 2000, 2019 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -47,6 +47,8 @@
 import org.eclipse.jdt.debug.core.IEvaluationRunnable;
 import org.eclipse.jdt.debug.core.IJavaBreakpoint;
 import org.eclipse.jdt.debug.core.IJavaBreakpointListener;
+import org.eclipse.jdt.debug.core.IJavaExceptionBreakpoint;
+import org.eclipse.jdt.debug.core.IJavaExceptionBreakpoint.SuspendOnRecurrenceStrategy;
 import org.eclipse.jdt.debug.core.IJavaObject;
 import org.eclipse.jdt.debug.core.IJavaStackFrame;
 import org.eclipse.jdt.debug.core.IJavaThread;
@@ -58,6 +60,7 @@
 import org.eclipse.jdt.internal.debug.core.JDIDebugPlugin;
 import org.eclipse.jdt.internal.debug.core.breakpoints.ConditionalBreakpointHandler;
 import org.eclipse.jdt.internal.debug.core.breakpoints.JavaBreakpoint;
+import org.eclipse.jdt.internal.debug.core.breakpoints.JavaExceptionBreakpoint;
 import org.eclipse.jdt.internal.debug.core.breakpoints.JavaLineBreakpoint;
 import org.eclipse.jdt.internal.debug.core.model.MethodResult.ResultType;
 
@@ -307,6 +310,11 @@
 	private MethodResult fMethodResult;
 
 	/**
+	 * If previous suspend was on an exception breakpoint, this variable holds that Java exception instance, else {@code null}.
+	 */
+	private IJavaObject fPreviousException;
+
+	/**
 	 * Creates a new thread on the underlying thread reference in the given
 	 * debug target.
 	 *
@@ -1506,6 +1514,33 @@
 	}
 
 	/**
+	 * To be called whenever a Java exception breakpoint is called. This thread will remember the Java exception instance associated with this event
+	 * and will answer if suspending should be skipped as per the breakpoint's {@link IJavaExceptionBreakpoint.SuspendOnRecurrenceStrategy suspend on
+	 * recurrence} strategy.
+	 *
+	 * @param breakpoint
+	 *            the breakpoint about to trigger
+	 * @return either {@code null} to signal that this breakpoint hit is not a recurrence, or one of
+	 *         {@link SuspendOnRecurrenceStrategy#RECURRENCE_UNCONFIGURED}, {@link SuspendOnRecurrenceStrategy#SKIP_RECURRENCES}, or
+	 *         {@link SuspendOnRecurrenceStrategy#SUSPEND_ALWAYS}.
+	 */
+	public SuspendOnRecurrenceStrategy shouldSkipExceptionRecurrence(IJavaExceptionBreakpoint breakpoint) {
+		if (breakpoint instanceof JavaExceptionBreakpoint) {
+			JavaExceptionBreakpoint exceptionBreakpoint = (JavaExceptionBreakpoint) breakpoint;
+			try {
+				IJavaObject lastException = exceptionBreakpoint.getLastException();
+				if (fPreviousException != null && fPreviousException.equals(lastException)) {
+					return exceptionBreakpoint.getSuspendOnRecurrenceStrategy();
+				}
+				fPreviousException = lastException;
+			} catch (CoreException e) {
+				// ignore
+			}
+		}
+		return null; // skipping not applicable, since this is no recurrence
+	}
+
+	/**
 	 * Called after an event set with a breakpoint is done being processed.
 	 * Updates thread state based on the result of handling the event set.
 	 * Aborts any step in progress and fires a suspend event is suspending.
diff --git a/org.eclipse.jdt.debug/pom.xml b/org.eclipse.jdt.debug/pom.xml
index c14300e..7193858 100644
--- a/org.eclipse.jdt.debug/pom.xml
+++ b/org.eclipse.jdt.debug/pom.xml
@@ -18,6 +18,6 @@
   </parent>
   <groupId>org.eclipse.jdt</groupId>
   <artifactId>org.eclipse.jdt.debug</artifactId>
-  <version>3.13.200-SNAPSHOT</version>
+  <version>3.14.0-SNAPSHOT</version>
   <packaging>eclipse-plugin</packaging>
 </project>