LCC– Wie kann verhindert werden, dass der Debugger beim Start der Anwendung abbricht?

Lesezeit: 4 Minuten

Benutzer-Avatar
RLH

Ich bin mir nicht sicher, wie viele Benutzer da draußen den LCC-C-Compiler und die WEdit-GUI für Windows verwenden, aber es hat ein “Feature”, das ziemlich lästig werden kann. Wenn Sie eine Anwendung mit dem Debugger starten, wird die Anwendung beim Start der Main-Funktion unterbrochen. Wie kann ich dies abschneiden, damit der Debugger den Code sofort ausführt, bis ich ihn anhalte oder einen von mir erstellten Haltepunkt erreicht?

  • Gute Frage! Ich habe in der Vergangenheit LCC-Win32 zum Unterrichten von C verwendet, und für Neulinge ist dies eine gute Funktion, aber ich kann sehen, wie es lästig werden kann. Ich habe versucht, einen Haltepunkt an der öffnenden geschweiften Klammer in main() zu setzen und aufzuheben, aber so oder so hört es dort auf. Ich habe mir die Befehlszeilenparameter von Wedit (der IDE für LCC-Win32) angesehen, aber es gibt keine Flags, die steuern, was es beim Start tut.

    – Jay Elston

    10. August 2011 um 19:08 Uhr

  • Ich bin mit LCC nicht vertraut, aber aus der Benutzerdokumentation – “Sie können alle vorhandenen Haltepunkte anzeigen und bearbeiten / entfernen, indem Sie im Menü Compiler-> Haltepunkte (oder Debug-> Haltepunkte bearbeiten) auswählen”. Haben Sie hier den Haltepunkt auf main() gesehen?

    – Sergei Nikulov

    26. August 2011 um 0:41 Uhr

  • Es gibt keinen Haltepunkt. Das Ärgerliche ist, egal ob ein Breakpoint gesetzt ist oder nicht, der Debugger/Editor bricht immer in der ersten Zeile der Methode main() ab.

    – RLH

    26. August 2011 um 12:31 Uhr

  • in Windbg und VS gibt es eine Programmoption, um dies zu steuern. Vielleicht hast du das vor

    – Jim Deville

    19. November 2011 um 5:28 Uhr

  • Ist das nicht spezifisch für lcc-win32, im Gegensatz zum ursprünglichen lcc, auf dem es basiert? Wenn ja, möchten Sie vielleicht den Titel bearbeiten.

    – Keith Thompson

    19. November 2011 um 21:19 Uhr

Benutzer-Avatar
Experte

Wow, die Leute benutzen immer noch LCC … Das letzte Mal, dass ich es benutzt habe, war vor ungefähr 10 Jahren.

Ich habe dekompiliert wedit.exe und kann bestätigen, dass es keine offizielle Möglichkeit gibt, dieses Verhalten zu deaktivieren.

Ich habe die Binärdatei gepatcht, wenn das für Sie funktioniert. Ich habe es hochgeladen hier.

An diejenigen, die sich Sorgen um Viren und dergleichen machen, die ich gepatcht habe wedit genommen von hier. About Box sagt, dass es Version 4.0 ist, die am 16. September 2009 kompiliert wurde.

Hier ist die gepatchte Funktion für diejenigen, die daran interessiert sind:

int __cdecl sub_44CF0D(HANDLE hProcess)
{
  int result; // eax@1
  int v2; // ST0C_4@10
  int v3; // eax@20
  int v4; // eax@23
  int v5; // eax@25
  int v6; // [sp+10h] [bp-68h]@11
  int v7; // [sp+14h] [bp-64h]@1
  struct _DEBUG_EVENT DebugEvent; // [sp+18h] [bp-60h]@1

  v7 = 1;
  result = WaitForDebugEvent(&DebugEvent, dwMilliseconds);
  if ( result )
  {
    sub_44C67A(&DebugEvent);
    if ( DebugEvent.dwDebugEventCode == 1 )
    {
      if ( DebugEvent.u.Exception.ExceptionRecord.ExceptionCode == EXCEPTION_ACCESS_VIOLATION
        && !(dword_482860 & 1)
        && !dword_484328
        && DebugEvent.u.Exception.dwFirstChance )
      {
        sub_44E1A5(0);
        sub_44CEB2(v2);
        return ContinueDebugEvent(DebugEvent.dwProcessId, DebugEvent.dwThreadId, 0x80010001u);
      }
      v6 = 0;
      v7 = sub_44D2C4((int)&DebugEvent, hProcess, (int)&v6);
      if ( v6 && DebugEvent.u.Exception.dwFirstChance )
        return ContinueDebugEvent(DebugEvent.dwProcessId, DebugEvent.dwThreadId, 0x80010001u);
      goto LABEL_41;
    }
    if ( DebugEvent.dwDebugEventCode == 3 )
    {
      if ( dword_483C94 )
      {
        dword_48428C = 1;
LABEL_41:
        if ( dword_483C6C )
          sub_44ECDC();
        if ( v7 )
        {
          result = ContinueDebugEvent(DebugEvent.dwProcessId, DebugEvent.dwThreadId, 0x10002u);
        }
        else
        {
          dword_49BF68 = 1;
          ResetEvent(dword_484AE4);
          dword_4843C8 = DebugEvent.dwThreadId;
          result = sub_4524CD();
        }
        return result;
      }
      Sleep(0x32u);
      dword_49BF64 = 1;
      dword_49BF68 = 1;
      qword_483C74 = __PAIR__(
                       (unsigned int)DebugEvent.u.Exception.ExceptionRecord.ExceptionAddress,
                       DebugEvent.u.Exception.ExceptionRecord.ExceptionInformation[2]);
      if ( dword_484288 )
        ::hProcess = (HANDLE)DebugEvent.u.Exception.ExceptionRecord.ExceptionFlags;
      else
        ::hProcess = hProcess;
      dword_483C84 = DebugEvent.dwProcessId;
      hThread = DebugEvent.u.Exception.ExceptionRecord.ExceptionRecord;
      dword_483C9C = (HANDLE)DebugEvent.u.Exception.ExceptionRecord.ExceptionCode;
      dwThreadId = DebugEvent.dwThreadId;
      dword_483C94 = 0;
      if ( sub_45A83A() )
      {
        v4 = sub_4026A6(28);
        dword_484330 = v4;
        *(_DWORD *)(v4 + 4) = hThread;
        *(_DWORD *)(v4 + 8) = dwThreadId;
        if ( dword_484288 )
        {
          sub_455B58();
        }
        else
        {
          Sleep(0x64u);
          v5 = sub_45AAFC();
          if ( !v5 )
            return PostMessageA(dword_4849EC, 0x111u, 0x64u, 0);
          if ( dword_484354 )
            goto LABEL_50;
          sub_455B58();
          if ( dword_483C70 && *(_DWORD *)(dword_483C70 + 52) )
            *(_DWORD *)(*(_DWORD *)(dword_483C70 + 52) + 36) = sub_451577(**(_DWORD **)(dword_483C70 + 52), 1u);
          v5 = *(_DWORD *)(dword_483C70 + 52);
          if ( v5 && *(_DWORD *)(v5 + 36) )
          {
LABEL_50:
            if ( !dword_483C6C )
              sub_44E92A(v5);
            sub_44CC3D();
            sub_451600();
            PostMessageA(dword_4849EC, 0x111u, 0x154u, 0);
          }
          else
          {
            sub_4029CA("Imposible to find %s\nRunning without source display", *(_DWORD *)(dword_483C70 + 20));
            dword_484344 = 1;
            v7 = 1;
            PostMessageA(dword_4849EC, 0x111u, 0x154u, 0);
          }
        }
        goto LABEL_41;
      }
      dword_484338 = 1;
      v3 = sub_44DB56(qword_483C74);
      if ( v3 )
        *(_BYTE *)(v3 + 29) &= 0xFDu;
      result = ContinueDebugEvent(DebugEvent.dwProcessId, DebugEvent.dwThreadId, 0x10002u);
    }
    else
    {
      if ( DebugEvent.dwDebugEventCode != 5 )
        goto LABEL_41;
      if ( DebugEvent.dwProcessId != dword_483C84 )
      {
        v7 = 1;
        goto LABEL_41;
      }
      dword_49BF64 = 0;
      dword_49BF68 = 1;
      dword_481614 = 0;
      result = sub_402A32(4520, SLOBYTE(DebugEvent.u.Exception.ExceptionRecord.ExceptionCode));
      if ( !dword_483C6C )
        result = sub_40B155(lpCmdLine);
    }
  }
  else
  {
    if ( dword_483C6C )
      result = sub_44ECDC();
  }
  return result;
}

if unter LABEL_50 habe ich gepatcht (von 0x75 bis 0xEB).

Es war leicht, den Ort zu erkennen, weil ich es erwartet hatte WriteProcessMemory Wird verwendet, um 0xCC am Einstiegspunkt der Anwendung zu schreiben, die debuggt wird.

  • Nun, ich wollte eine Weile warten, bevor ich dies als Antwort markierte, nur für den Fall, dass sich eine andere Lösung bot. Dies löst sicherlich das Problem, nur nicht so elegant, wie ich gehofft hatte. Danke für die Lösung!

    – RLH

    3. Januar 2012 um 17:29 Uhr


1355330cookie-checkLCC– Wie kann verhindert werden, dass der Debugger beim Start der Anwendung abbricht?

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy