Warum kann die Erkennung von totem Code von einem Compiler nicht vollständig gelöst werden?

Die Compiler, die ich in C oder Java verwendet habe, verhindern toten Code (Warnung, wenn eine Zeile niemals ausgeführt wird). Mein Professor sagt, dass dieses Problem von Compilern niemals vollständig gelöst werden kann. Ich habe mich gefragt, warum das so ist. Ich bin mit der tatsächlichen Codierung von Compilern nicht allzu vertraut, da dies eine theoretische Klasse ist. Aber ich habe mich gefragt, was sie überprüfen (wie mögliche Eingabezeichenfolgen gegenüber akzeptablen Eingaben usw.) und warum dies nicht ausreicht.

Das Problem mit dem toten Code hängt mit dem Problem des Anhaltens zusammen .

Alan Turing hat bewiesen, dass es unmöglich ist, einen allgemeinen Algorithmus zu schreiben, der ein Programm erhält, und zu entscheiden, ob dieses Programm für alle Eingaben angehalten wird. Möglicherweise können Sie einen solchen Algorithmus für bestimmte Programmtypen schreiben, jedoch nicht für alle Programme.

Wie hängt das mit totem Code zusammen?

Das Problem des Anhaltens lässt sich auf das Problem reduzieren , toten Code zu finden. Wenn Sie also einen Algorithmus finden, der toten Code in einem Programm erkennen kann, können Sie diesen Algorithmus verwenden, um zu testen, ob ein Programm angehalten wird. Da sich dies als unmöglich erwiesen hat, ist das Schreiben eines Algorithmus für toten Code ebenfalls unmöglich.

Wie überträgt man einen Algorithmus für toten Code in einen Algorithmus für das Halting-Problem?

Einfach: Sie fügen nach dem Ende des Programms, das Sie auf Halt prüfen möchten, eine Codezeile hinzu. Wenn Ihr Dead-Code-Detektor feststellt, dass diese Zeile tot ist, wissen Sie, dass das Programm nicht angehalten wird. Wenn dies nicht der Fall ist, wissen Sie, dass Ihr Programm angehalten wird (bis zur letzten Zeile und dann bis zur hinzugefügten Codezeile).

Compiler prüfen normalerweise, ob Dinge, die zum Zeitpunkt der Kompilierung nachgewiesen werden können, tot sind. Zum Beispiel Blöcke, die von Bedingungen abhängig sind, die zum Zeitpunkt der Kompilierung als falsch bestimmt werden können. Oder eine Aussage nach a return(im gleichen Rahmen).

Dies sind spezielle Fälle, und daher ist es möglich, einen Algorithmus für sie zu schreiben. Es ist möglicherweise möglich, Algorithmen für kompliziertere Fälle zu schreiben (z. B. einen Algorithmus, der prüft, ob eine Bedingung syntaktisch ein Widerspruch ist und daher immer false zurückgibt), der jedoch nicht alle möglichen Fälle abdeckt.

Nehmen wir den klassischen Beweis für die Unentscheidbarkeit des Stoppproblems und ändern den Stoppdetektor in einen Totcodedetektor!

C # -Programm

using System;
using YourVendor.Compiler;

class Program
{
    static void Main(string[] args)
    {
        string quine_text = @"using System;
using YourVendor.Compiler;

class Program
{{
    static void Main(string[] args)
    {{
        string quine_text = @{0}{1}{0};
        quine_text = string.Format(quine_text, (char)34, quine_text);

        if (YourVendor.Compiler.HasDeadCode(quine_text))
        {{
            System.Console.WriteLine({0}Dead code!{0});
        }}
    }}
}}";
        quine_text = string.Format(quine_text, (char)34, quine_text);

        if (YourVendor.Compiler.HasDeadCode(quine_text))
        {
            System.Console.WriteLine("Dead code!");
        }
    }
}

Wenn YourVendor.Compiler.HasDeadCode(quine_text)Rückkehr false, dann ist die Linie System.Console.WriteLn("Dead code!");nicht immer ausgeführt werden, so dass dieses Programm tatsächlich nicht tot - Code, und der Detektor war falsch.

Wenn es jedoch zurückkehrt true, wird die Zeile System.Console.WriteLn("Dead code!");ausgeführt, und da das Programm keinen Code mehr enthält, gibt es überhaupt keinen toten Code. Auch hier war der Detektor falsch.

Da haben Sie es also, ein Totcodedetektor, der nur "Es gibt toten Code" oder "Es gibt keinen toten Code" zurückgibt, muss manchmal falsche Antworten liefern.

Wenn das Problem des Anhaltens zu dunkel ist, stellen Sie es sich so vor.

Nehmen Sie ein mathematisches Problem, von dem angenommen wird, dass es für alle positiven Ganzzahlen n gilt , das jedoch nicht für jedes n gilt . Ein gutes Beispiel wäre Goldbachs Vermutung , dass jede positive gerade ganze Zahl größer als zwei durch die Summe zweier Primzahlen dargestellt werden kann. Führen Sie dann (mit einer geeigneten Bigint-Bibliothek) dieses Programm aus (Pseudocode folgt):

 for (BigInt n = 4; ; n+=2) {
     if (!isGoldbachsConjectureTrueFor(n)) {
         print("Conjecture is false for at least one value of n\n");
         exit(0);
     }
 }

Die Implementierung von isGoldbachsConjectureTrueFor()bleibt als Übung für den Leser, könnte aber zu diesem Zweck eine einfache Iteration über alle Primzahlen sein, die kleiner als sindn

Logischerweise muss das Obige entweder das Äquivalent von sein:

 for (; ;) {
 }

(dh eine Endlosschleife) oder

print("Conjecture is false for at least one value of n\n");

wie Goldbachs Vermutung muss entweder wahr oder nicht wahr sein. Wenn ein Compiler immer toten Code eliminieren könnte, gäbe es in beiden Fällen definitiv toten Code, der hier eliminiert werden könnte. Dabei müsste Ihr Compiler jedoch zumindest beliebig schwierige Probleme lösen. Wir könnten Probleme bereitstellen, die nachweislich schwer zu lösen wären (z. B. NP-vollständige Probleme), um zu bestimmen, welches Codebit beseitigt werden soll. Zum Beispiel, wenn wir dieses Programm nehmen:

 String target = "f3c5ac5a63d50099f3b5147cabbbd81e89211513a92e3dcd2565d8c7d302ba9c";
 for (BigInt n = 0; n < 2**2048; n++) {
     String s = n.toString();
     if (sha256(s).equals(target)) {
         print("Found SHA value\n");
         exit(0);
     }
 }
 print("Not found SHA value\n");

Wir wissen, dass das Programm entweder "Gefundener SHA-Wert" oder "Nicht gefundener SHA-Wert" ausgibt (Bonuspunkte, wenn Sie mir sagen können, welcher wahr ist). Damit ein Compiler dies jedoch vernünftigerweise optimieren kann, würde dies in der Größenordnung von 2 ^ 2048 Iterationen liegen. Es wäre in der Tat eine großartige Optimierung, da ich voraussage, dass das obige Programm bis zum Hitzetod des Universums laufen würde (oder könnte), anstatt etwas ohne Optimierung zu drucken.

Ich weiß nicht, ob C ++ oder Java eine Typfunktion haben Eval, aber in vielen Sprachen können Sie Methoden nach Namen aufrufen . Betrachten Sie das folgende (erfundene) VBA-Beispiel.

Dim methodName As String

If foo Then
    methodName = "Bar"
Else
    methodName = "Qux"
End If

Application.Run(methodName)

Der Name der aufzurufenden Methode ist bis zur Laufzeit nicht bekannt. Daher kann der Compiler per Definition nicht mit absoluter Sicherheit wissen, dass eine bestimmte Methode niemals aufgerufen wird.

In Anbetracht des Beispiels, eine Methode beim Namen aufzurufen, ist die Verzweigungslogik nicht einmal erforderlich. Einfach sagen

Application.Run("Bar")

Ist mehr als der Compiler bestimmen kann. Wenn der Code kompiliert wird, weiß der Compiler nur, dass ein bestimmter Zeichenfolgenwert an diese Methode übergeben wird. Es wird erst zur Laufzeit überprüft, ob diese Methode vorhanden ist. Wenn die Methode nicht durch normalere Methoden an anderer Stelle aufgerufen wird, kann ein Versuch, tote Methoden zu finden, falsch positive Ergebnisse zurückgeben. Das gleiche Problem tritt in jeder Sprache auf, in der Code über Reflection aufgerufen werden kann.

Unbedingter toter Code kann von fortgeschrittenen Compilern erkannt und entfernt werden.

Es gibt aber auch bedingten toten Code. Dies ist Code, der zum Zeitpunkt der Kompilierung nicht bekannt ist und nur zur Laufzeit erkannt werden kann. Beispielsweise kann eine Software so konfiguriert werden, dass bestimmte Funktionen je nach Benutzerpräferenz ein- oder ausgeschlossen werden, wodurch bestimmte Codeabschnitte in bestimmten Szenarien scheinbar tot erscheinen. Das ist kein wirklich toter Code.

Es gibt spezielle Tools, mit denen Sie Tests durchführen, Abhängigkeiten auflösen, bedingten toten Code entfernen und den nützlichen Code zur Laufzeit aus Effizienzgründen neu kombinieren können. Dies wird als dynamische Eliminierung von totem Code bezeichnet. Aber wie Sie sehen, geht es über den Rahmen von Compilern hinaus.

Ein einfaches Beispiel:

int readValueFromPort(const unsigned int portNum);

int x = readValueFromPort(0x100); // just an example, nothing meaningful
if (x < 2)
{
    std::cout << "Hey! X < 2" << std::endl;
}
else
{
    std::cout << "X is too big!" << std::endl;
}

Nehmen wir nun an, dass der Port 0x100 nur 0 oder 1 zurückgibt. In diesem Fall kann der Compiler nicht herausfinden, dass der elseBlock niemals ausgeführt wird.

In diesem grundlegenden Beispiel jedoch:

bool boolVal = /*anything boolean*/;

if (boolVal)
{
  // Do A
}
else if (!boolVal)
{
  // Do B
}
else
{
  // Do C
}

Hier kann der Compiler die berechnen else Block ein toter Code ist. Der Compiler kann also nur dann vor dem toten Code warnen, wenn er über genügend Daten verfügt, um den toten Code herauszufinden, und er sollte auch wissen, wie diese Daten angewendet werden, um herauszufinden, ob der angegebene Block ein toter Code ist.

BEARBEITEN

Manchmal sind die Daten zum Zeitpunkt der Kompilierung einfach nicht verfügbar:

// File a.cpp
bool boolMethod();

bool boolVal = boolMethod();

if (boolVal)
{
  // Do A
}
else
{
  // Do B
}

//............
// File b.cpp
bool boolMethod()
{
    return true;
}

Beim Kompilieren von a.cpp kann der Compiler nicht wissen, dass boolMethodimmer zurückgegeben wird true.

Dem Compiler fehlen immer einige Kontextinformationen. Sie wissen vielleicht, dass ein Doppelwert niemals 2 überschreitet, da dies ein Merkmal der mathematischen Funktion ist, die Sie aus einer Bibliothek verwenden. Der Compiler sieht nicht einmal den Code in der Bibliothek, und er kann niemals alle Merkmale aller mathematischen Funktionen kennen und alle unerwünschten und komplizierten Möglichkeiten erkennen, sie zu implementieren.

Der Compiler sieht nicht unbedingt das gesamte Programm. Ich könnte ein Programm haben, das eine gemeinsam genutzte Bibliothek aufruft, die eine Funktion in meinem Programm aufruft, die nicht direkt aufgerufen wird.

Eine Funktion, die in Bezug auf die Bibliothek, für die sie kompiliert wurde, tot ist, könnte also lebendig werden, wenn diese Bibliothek zur Laufzeit geändert wird.

Wenn ein Compiler den gesamten toten Code genau eliminieren könnte, würde er als Interpreter bezeichnet .

Stellen Sie sich dieses einfache Szenario vor:

if (my_func()) {
  am_i_dead();
}

my_func() kann beliebigen Code enthalten, und damit der Compiler feststellen kann, ob er true oder false zurückgibt, muss er entweder den Code ausführen oder etwas tun, das funktional dem Ausführen des Codes entspricht.

Die Idee eines Compilers ist, dass er nur eine teilweise Analyse des Codes durchführt, wodurch die Arbeit einer separaten laufenden Umgebung vereinfacht wird. Wenn Sie eine vollständige Analyse durchführen, ist dies kein Compiler mehr.

Wenn Sie den Compiler als eine Funktion betrachten c(), wo c(source)=compiled codeund die laufende Umgebung als r(), wo r(compiled code)=program output, müssen Sie den Wert von berechnen, um die Ausgabe für einen beliebigen Quellcode zu bestimmen r(c(source code)). Wenn Rechen c()das Wissen des Wertes erfordert r(c())für jede Eingabe, gibt es keine Notwendigkeit für einen separaten r()und c(): Sie nur eine Funktion ableiten i()aus , c()so dass i(source)=program output.

Andere haben das Problem des Anhaltens usw. kommentiert. Diese gelten im Allgemeinen für Teile von Funktionen. Es kann jedoch schwierig / unmöglich sein zu wissen, ob auch nur ein ganzer Typ (Klasse / usw.) verwendet wird oder nicht.

In .NET / Java / JavaScript und anderen zur Laufzeit gesteuerten Umgebungen hindert nichts das Laden von Typen über Reflection. Dies ist bei Abhängigkeitsinjektions-Frameworks beliebt und angesichts der Deserialisierung oder des Ladens dynamischer Module noch schwieriger zu begründen.

Der Compiler kann nicht wissen, ob solche Typen geladen werden würden. Ihre Namen könnten zur Laufzeit aus externen Konfigurationsdateien stammen.

Möglicherweise möchten Sie nach Baumschütteln suchen, was ein häufiger Begriff für Tools ist, die versuchen, nicht verwendete Untergraphen von Code sicher zu entfernen.

Nehmen Sie eine Funktion

void DoSomeAction(int actnumber) 
{
    switch(actnumber) 
    {
        case 1: Action1(); break;
        case 2: Action2(); break;
        case 3: Action3(); break;
    }
}

Können Sie beweisen, dass actnumberdas niemals 2so sein wird, dass Action2()es niemals heißt ...?

Ich bin nicht einverstanden mit dem Problem des Anhaltens. Ich würde einen solchen Code nicht als tot bezeichnen, obwohl er in Wirklichkeit niemals erreicht werden kann.

Betrachten wir stattdessen:

for (int N = 3;;N++)
  for (int A = 2; A < int.MaxValue; A++)
    for (int B = 2; B < int.MaxValue; B++)
    {
      int Square = Math.Pow(A, N) + Math.Pow(B, N);
      float Test = Math.Sqrt(Square);
      if (Test == Math.Trunc(Test))
        FermatWasWrong();
    }

private void FermatWasWrong()
{
  Press.Announce("Fermat was wrong!");
  Nobel.Claim();
}

(Typ- und Überlauffehler ignorieren) Toter Code?

Schauen Sie sich dieses Beispiel an:

public boolean isEven(int i){

    if(i % 2 == 0)
        return true;
    if(i % 2 == 1)
        return false;
    return false;
}

Der Compiler kann nicht wissen, dass ein int nur gerade oder ungerade sein kann. Daher muss der Compiler in der Lage sein, die Semantik Ihres Codes zu verstehen. Wie soll dies umgesetzt werden? Der Compiler kann nicht sicherstellen, dass die niedrigste Rückgabe niemals ausgeführt wird. Daher kann der Compiler den toten Code nicht erkennen.