CDB: Add setting to add breakpoint at CrtDbgReport().

- Factor out message/tooltips for breakpoints on functions.
- Add stringlist of break functions to CdbOptions.
- Set breakpoints with module, ignore response.

Change-Id: If5cf7647b190057c18d8499b9f4862696610e4f6
Reviewed-by: hjk <qthjk@ovi.com>

src/plugins/debugger/cdb/cdbengine.cpp

@@ -775,12 +775,59 @@ void CdbEngine::setupInferior()
     postExtensionCommand("pid", QByteArray(), 0, &CdbEngine::handlePid);
 }
 
+static QByteArray msvcRunTime(const Abi::OSFlavor flavour)
+{
+    switch (flavour)  {
+    case Abi::WindowsMsvc2005Flavor:
+        return "MSVCR80";
+    case Abi::WindowsMsvc2008Flavor:
+        return "MSVCR90";
+    case Abi::WindowsMsvc2010Flavor:
+        return "MSVCR100";
+    case Abi::WindowsMsvc2012Flavor:
+        return "MSVCR110"; // #FIXME: VS2012 beta, will probably be 12 in final?
+    default:
+        break;
+    }
+    return "MSVCRT"; // MinGW, others.
+}
+
+static QByteArray breakAtFunctionCommand(const QByteArray &function,
+                                         const QByteArray &module = QByteArray())
+{
+     QByteArray result = "bu ";
+     if (!module.isEmpty()) {
+         result += module;
+         result += '!';
+     }
+     result += function;
+     return result;
+}
+
 void CdbEngine::runEngine()
 {
     if (debug)
         qDebug("runEngine");
     foreach (const QString &breakEvent, m_options->breakEvents)
             postCommand(QByteArray("sxe ") + breakEvent.toAscii(), 0);
+    // Break functions: each function must be fully qualified,
+    // else the debugger will slow down considerably.
+    foreach (const QString &breakFunctionS, m_options->breakFunctions) {
+        const QByteArray breakFunction = breakFunctionS.toLatin1();
+        if (breakFunction == CdbOptions::crtDbgReport) {
+            // CrtDbgReport(): Add MSVC runtime (debug, release)
+            // and stop at Wide character version as well
+            const QByteArray module = msvcRunTime(startParameters().toolChainAbi.osFlavor());
+            const QByteArray debugModule = module + 'D';
+            const QByteArray wideFunc = breakFunction + 'W';
+            postCommand(breakAtFunctionCommand(breakFunction, module), 0);
+            postCommand(breakAtFunctionCommand(wideFunc, module), 0);
+            postCommand(breakAtFunctionCommand(breakFunction, debugModule), 0);
+            postCommand(breakAtFunctionCommand(wideFunc, debugModule), 0);
+        } else {
+            postCommand(breakAtFunctionCommand(breakFunction), 0);
+        }
+    }
     if (startParameters().startMode == AttachCore) {
         QTC_ASSERT(!m_coreStopReason.isNull(), return; );
         notifyInferiorUnrunnable();
@@ -2990,6 +3037,8 @@ void CdbEngine::handleBreakPoints(const GdbMi &value)
                 qPrintable(reportedResponse.toString()));
         if (reportedResponse.id.isValid() && !reportedResponse.pending) {
             const BreakpointModelId mid = handler->findBreakpointByResponseId(reportedResponse.id);
+            if (!mid.isValid() && reportedResponse.type == BreakpointByFunction)
+                continue; // Breakpoints from options, CrtDbgReport() and others.
             QTC_ASSERT(mid.isValid(), continue);
             const PendingBreakPointMap::iterator it = m_pendingBreakpointMap.find(mid);
             if (it != m_pendingBreakpointMap.end()) {

src/plugins/debugger/cdb/cdboptions.cpp

@@ -36,6 +36,7 @@ static const char settingsGroupC[] = "CDB2";
 static const char symbolPathsKeyC[] = "SymbolPaths";
 static const char sourcePathsKeyC[] = "SourcePaths";
 static const char breakEventKeyC[] = "BreakEvent";
+static const char breakFunctionsKeyC[] = "BreakFunctions";
 static const char additionalArgumentsKeyC[] = "AdditionalArguments";
 static const char cdbConsoleKeyC[] = "CDB_Console";
 static const char breakpointCorrectionKeyC[] = "BreakpointCorrection";
@@ -43,6 +44,8 @@ static const char breakpointCorrectionKeyC[] = "BreakpointCorrection";
 namespace Debugger {
 namespace Internal {
 
+const char *CdbOptions::crtDbgReport = "CrtDbgReport";
+
 CdbOptions::CdbOptions() : cdbConsole(false), breakpointCorrection(true)
 {
 }
@@ -57,6 +60,8 @@ void CdbOptions::clear()
     symbolPaths.clear();
     sourcePaths.clear();
     cdbConsole = false;
+    breakEvents.clear();
+    breakFunctions.clear();
 }
 
 QStringList CdbOptions::oldEngineSymbolPaths(const QSettings *s)
@@ -72,6 +77,7 @@ void CdbOptions::fromSettings(QSettings *s)
     symbolPaths = s->value(keyRoot + QLatin1String(symbolPathsKeyC), QStringList()).toStringList();
     sourcePaths = s->value(keyRoot + QLatin1String(sourcePathsKeyC), QStringList()).toStringList();
     breakEvents = s->value(keyRoot + QLatin1String(breakEventKeyC), QStringList()).toStringList();
+    breakFunctions = s->value(keyRoot + QLatin1String(breakFunctionsKeyC), QStringList()).toStringList();
     cdbConsole = s->value(keyRoot + QLatin1String(cdbConsoleKeyC), QVariant(false)).toBool();
     breakpointCorrection = s->value(keyRoot + QLatin1String(breakpointCorrectionKeyC), QVariant(true)).toBool();
 }
@@ -82,6 +88,7 @@ void CdbOptions::toSettings(QSettings *s) const
     s->setValue(QLatin1String(symbolPathsKeyC), symbolPaths);
     s->setValue(QLatin1String(sourcePathsKeyC), sourcePaths);
     s->setValue(QLatin1String(breakEventKeyC), breakEvents);
+    s->setValue(QLatin1String(breakFunctionsKeyC), breakFunctions);
     s->setValue(QLatin1String(additionalArgumentsKeyC), additionalArguments);
     s->setValue(QLatin1String(cdbConsoleKeyC), QVariant(cdbConsole));
     s->setValue(QLatin1String(breakpointCorrectionKeyC), QVariant(breakpointCorrection));
@@ -95,7 +102,8 @@ bool CdbOptions::equals(const CdbOptions &rhs) const
             && additionalArguments == rhs.additionalArguments
             && symbolPaths == rhs.symbolPaths
             && sourcePaths == rhs.sourcePaths
-            && breakEvents == rhs.breakEvents;
+            && breakEvents == rhs.breakEvents
+            && breakFunctions == rhs.breakFunctions;
 }
 
 } // namespace Internal

src/plugins/debugger/cdb/cdboptions.h

@@ -62,10 +62,13 @@ public:
     QStringList sourcePaths;
     // Events to break on (Command 'sxe' with abbreviation and optional parameter)
     QStringList breakEvents;
+    QStringList breakFunctions;
     // Launch CDB's own console instead of Qt Creator's
     bool cdbConsole;
     // Perform code-model based correction of breakpoint location.
     bool breakpointCorrection;
+
+    static const char *crtDbgReport;
 };
 
 inline bool operator==(const CdbOptions &s1, const CdbOptions &s2)

src/plugins/debugger/cdb/cdboptionspage.cpp

@@ -30,6 +30,7 @@
 
 #include "cdboptionspage.h"
 #include "cdboptions.h"
+#include "commonoptionspage.h"
 #include "debuggerinternalconstants.h"
 #include "cdbengine.h"
 
@@ -176,6 +177,11 @@ CdbOptionsPageWidget::CdbOptionsPageWidget(QWidget *parent) :
     eventLayout->setContentsMargins(margins);
     eventLayout->addWidget(m_breakEventWidget);
     m_ui.eventGroupBox->setLayout(eventLayout);
+    m_ui.breakCrtDbgReportCheckBox
+        ->setText(CommonOptionsPage::msgSetBreakpointAtFunction(CdbOptions::crtDbgReport));
+    const QString hint = tr("This is useful to catch runtime error messages, for example caused by assert().");
+    m_ui.breakCrtDbgReportCheckBox
+        ->setToolTip(CommonOptionsPage::msgSetBreakpointAtFunctionToolTip(CdbOptions::crtDbgReport, hint));
 }
 
 void CdbOptionsPageWidget::setOptions(CdbOptions &o)
@@ -186,6 +192,7 @@ void CdbOptionsPageWidget::setOptions(CdbOptions &o)
     m_breakEventWidget->setBreakEvents(o.breakEvents);
     m_ui.consoleCheckBox->setChecked(o.cdbConsole);
     m_ui.breakpointCorrectionCheckBox->setChecked(o.breakpointCorrection);
+    m_ui.breakCrtDbgReportCheckBox->setChecked(o.breakFunctions.contains(QLatin1String(CdbOptions::crtDbgReport)));
 }
 
 CdbOptions CdbOptionsPageWidget::options() const
@@ -197,6 +204,8 @@ CdbOptions CdbOptionsPageWidget::options() const
     rc.breakEvents = m_breakEventWidget->breakEvents();
     rc.cdbConsole = m_ui.consoleCheckBox->isChecked();
     rc.breakpointCorrection = m_ui.breakpointCorrectionCheckBox->isChecked();
+    if (m_ui.breakCrtDbgReportCheckBox->isChecked())
+        rc.breakFunctions.push_back(QLatin1String(CdbOptions::crtDbgReport));
     return rc;
 }
 

src/plugins/debugger/cdb/cdboptionspagewidget.ui

@@ -120,6 +120,18 @@
      </property>
     </widget>
    </item>
+   <item>
+    <widget class="QGroupBox" name="breakFunctionGroupBox">
+     <property name="title">
+      <string>Break on functions:</string>
+     </property>
+     <layout class="QVBoxLayout" name="verticalLayout_2">
+      <item>
+       <widget class="QCheckBox" name="breakCrtDbgReportCheckBox"/>
+      </item>
+     </layout>
+    </widget>
+   </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">