Immer Die Größe einer C++ - Funktion

Las ich diese Frage, weil ich versuche zu finden, die Größe einer Funktion in einem C++ - Programm, Es wird angedeutet, dass es vielleicht ein Weg, dass ist Plattform-spezifisch. Meine Zielplattform ist windows

Die Methode, die ich derzeit noch in meinem Kopf ist folgende:

1. Sie erhalten einen Zeiger auf die Funktion

2. Erhöhen Sie den Zeiger (& counter), bis ich erreicht die Maschine code-Wert für ret

3. Der Zähler wird die Größe der Funktion?

Edit1: um Zu verdeutlichen, was ich damit meine "Größe" meine ich, dass die Anzahl der bytes (Maschinen-code), aus denen sich die Funktion.

Edit2: Es wurden ein paar Kommentare und Fragen, warum oder was ich Plane zu tun. Die ehrliche Antwort ist, ich habe keine Absicht, und ich kann nicht wirklich sehen, den nutzen von wissen ein-Funktionen Länge der pre-compile-Zeit. (obwohl ich bin sicher, es gibt einige)

Scheint das eine gültige Methode, um mich, werden Sie diese Arbeit?

Und Sie wollen dies tun, weil...?
Unsicher, aber wenn eine Funktion mehrere gibt. Bedeutet das nicht, dass Sie immer fehlerhafte Ergebnisse ?
Was ist, wenn es mehr als eine ret? Was ist, wenn die Funktion inlined? Was ist, wenn die Funktion sub-Funktionen eingebettet in es?
Schlechte Idee. Was genau wollen Sie archivieren?
Durch die Art und Weise, C++ ist nicht besser als C auf diese Weise, wenn nicht noch schlimmer.
diese Frage ist so seltsam, dass es sein muss, für hack/exploit-code. Aus dieser Sicht, die ich weigere mich zu unterhalten, diese Frage.
Irgendwo, ich kann Ihnen versichern, es ist für pädagogische Zwecke nur.
Es ist traurig zu sehen, so viele negative Antworten auf eine Frage, die man einfach hätte in der Verfolgung von hart-zu-erhalten Kenntnisse über computer-Architektur. Wir sollten die OP den Vorteil des Zweifels.
Es gab eine Menge von Kommentaren/Antworten mit hinweisen auf Fallstricke, aber nur wenige (nur eine oder zwei, soweit ich das sagen kann), die nur die bash die Frage. Ich habe eigentlich erwartet, dass es um downvotes und/oder in der Nähe Stimmen, aber soweit ich sehen kann keiner von denen.
zum Zeitpunkt meines Kommentars waren es drei von sechs nicht-OP-Kommentare, die sagen das ist eine schlechte Idee, böswillig oder sinnlos. Nicht zu verstehen, den Punkt von etwas und die Frage ist üblich und sinnvoll SO, aber der Ton der diese waren definitiv ablehnend.
fsmc ist richtig, die Mehrheit der frühen Kommentare waren auf jeden Fall in dieser form, und ich habe den gleichen Ton von Ihnen als gut. Aber ich habe einige nützliche Antworten (Speziell Micheal Madsen & dsmc ist), ich denke, ich werde einen Blick in einige Demontage Bibliotheken und sehen, ob ich finden kann, eine verlässliche Methode. 😉
Mögliche Duplikate von: stackoverflow.com/questions/3569877/...
Adam: Haben einige dieser Kommentare gelöscht wurden? Für das Protokoll, ich glaube nicht, dass die Kommentare, die angibt, dass das eine schlechte Idee oder Fragen, warum Sie wollen, dies zu tun, sind negativ. Oft fragt jemand eine Frage zu einem bestimmten Ansatz zur Lösung eines Problems, wenn das, was Sie wirklich Fragen sollten, ist, was Vorgehen sollte. Manchmal kann es schwierig sein zu bestimmen, von einer Frage, ob es die 'Akademische', oder wenn es ist wirklich über einige unausgesprochene Ziel. Zugegeben, einige der Kommentare, die vielleicht knapp, aber das bedeutet nicht, dass Sie dazu bestimmt waren, negativ zu sein. Sicherlich nicht beleidigend, richtig?
dass etwas eine schlechte Idee, UND nicht verstehen, den Punkt oder Zweck (impliziert durch die Fragen "warum tun dies" nach dem Aufruf eine schlechte Idee), gleichzeitig ist darauf hindeutet, dass es sinnlos ist. Der Sinn eines solchen Kommentars ist eindeutig nicht zu ermitteln, ob Akademische oder nicht. Unter der Annahme, dass etwas neugierig, muss bösartig sein ist auch nicht so schön. Es gibt viele Wege zu Fragen, warum jemand wollen, um etwas zu tun. Ein curt Beispiel wäre "was machst du das?", aber die Fragen hier sind mehr und schlage vor, die Frage nicht sinnvoll.

InformationsquelleAutor Adam | 2011-04-13

c++code-size windows

12

Nein, das wird nicht funktionieren:
1. Es gibt keine Garantie, dass Ihre Funktion enthält nur eine einzige ret Unterricht.
2. Auch wenn es nur enthält ein einziges ret können Sie nicht nur Blick auf die einzelnen bytes - weil der entsprechende Wert erscheinen könnte, als einfach nur ein Wert, sondern als eine Anleitung.
Das erste problem kann möglicherweise umgangen werden, wenn Sie beschränken Sie Ihre coding-Stil zu, sagen wir, nur einen einzelnen Punkt der Rückkehr in Ihre Funktion, aber die anderen erfordert grundsätzlich ein disassembler also man kann sagen, die einzelnen Anweisungen voneinander entfernt.
- Die Funktion wird nie inlined, wenn irgendwo im Programm, er fordert eine Funktion Zeiger darauf. Einigten sich auf den "Dies ist in der Regel nicht möglich / schwierig" Begriff obwohl.
- +1: ich habe Bedenken, dass die Funktion inline, was nicht der Fall ist. Allerdings, ich nicht betrachten mehrere rets oder die Möglichkeit eines arg mit den entsprechenden opcode-Wert
- Darüber hinaus gibt es nichts, das sagt, dass das Gesamtergebnis für eine Funktion muss zusammenhängend sein. Vor allem bei der Optimierung, die der compiler (und linker) wird statt code-Blöcke alle über dem Platz (vor der Funktion, vielleicht in der Mitte der Funktion), zu vermeiden, dass die Zweige im code, der es glaubt, zu den "heißen" Weg, um die Sprungziele in bestimmten Ausrichtungen, oder verschmelzen identische Befehlsfolgen (oder was auch immer). Der Punkt ist, dass es noch eine weitere Sache, die macht dieses einen Narren Botengang.
- Nach dem Sinn von Michaels Kommentar, es müssen ja auch nicht enthalten ret Linie. GCC ist manchmal Optimierungen, wo es springt einfach in eine andere Funktion/block enthält die ret schon. Ich nehme an, wenn es beendet nur mit Ausnahmen es möglicherweise nicht über eine Rückkehr entweder.
- Selbst wenn, ändern Sie Ihre C/C++ coding style haben nur ein return pro Funktion, es gibt keine Garantie, dass der compiler/optimizer emittiert assembly-code, der das gleiche tut!
- Ah ja, natürlich - mein Fehler. Ich habe entfernt das bit wieder. @Drew: Also das Wort "möglicherweise". 🙂
- Zusätzlich zu all den tollen Argumenten bereits angesprochen, niemand hat erwähnt, dass in der variable-width-Befehl setzt (wie x86), ist es nicht mal möglich, zuverlässig zu disassemblieren von code, ohne es auszuführen. Betrachten Sie zum Beispiel die Montage jmp Cont; db 01; Cont: ... ist, legen Sie die byte - 0x01 zwischen den jmp - Anweisung und der next-Anweisung. Wenn Sie die Schritte durch, es gibt keine Möglichkeit für Sie zu wissen, dass die 0x01 nicht der start des nächsten Befehls, also alles zerlegt, nach diesem Punkt wird sein Müll. Dies ist der Grund, warum es so schwer ist zu schreiben, ein disassembler für x86.
- stackoverflow.com/questions/11410037/...
InformationsquelleAutor Michael Madsen
13

Es ist möglich, um alle Blöcke der Funktion, sondern ist ein unnatürlicher Frage, was ist die 'Größe' einer Funktion. Optimierte code ordnen code-Blöcke in der Reihenfolge der Ausführung und bewegt sich nur selten genutzt Blöcke (Ausnahme Pfade) in die äußeren Teile des Moduls. Für mehr details, siehe Profil-Gesteuerte Optimierungen zum Beispiel, wie Sie mit Visual C++ erreicht dies in der link-time code generation. So eine Funktion kann beginnen bei Adresse 0 x 00001000, Niederlassung 0x00001100 in einem Sprung auf 0x20001000 und ein ret, und haben einige exception-handling-code 0x20001000. Bei 0x00001110 eine andere Funktion gestartet wird. Was ist die 'Größe' Ihrer Funktion? Es tut Spanne von 0 x 00001000 bis +0x20001000, aber es 'besitzt' nur paar Blöcke, die span. Also deine Frage sollte sein, ungefragt.

Gibt es andere, berechtigte Fragen in diesem Zusammenhang, wie die Gesamtzahl der Anweisungen, die eine Funktion hat (kann bestimmt werden aus der Programm-symbol-Datenbank und aus dem Bild), und noch wichtiger, was ist die Anzahl der Instruktionen in der Häufig ausgeführten code-Pfad in der Funktion. All dies sind Fragen, die eigentlich gestellt werden, im Kontext des performance measurement und gibt es tools, die instrument-code und kann damit sehr ausführlichen Antworten.

Jagen Zeiger im Speicher und auf der Suche nach ret bekommst du nirgendwo, fürchte ich. Moderne-code ist Weg, Weg, Weg, viel komplexer als das.
- Btw, das ist, was ich tun, um zu sehen, die 'Größe' einer Funktion: laden Sie das Modul in Windbg, dann uf module!functioname. uf hat einen ziemlich guten job bei voller Funktion der Demontage, selbst wenn der Umgang mit der code-Fetzen in Stücke von einer modernen generation/Optimierungs-tool, und ich kann sehen, dass die Anzahl der Anweisungen, Blöcke usw.
InformationsquelleAutor Remus Rusanu
10

Wow, ich verwenden Sie die Funktion Größe zählen alle die Zeit und es hat viele Verwendungen. Ist es zuverlässig? Kein Weg ist. Ist es standard c++? Kein Weg ist. Aber das ist, warum Sie überprüfen müssen, um es in den disassembler, um sicherzustellen, dass er funktioniert, dass man jedes mal eine neue version. Compiler-flags können mess up die Bestellung.
```
static void funcIwantToCount()
{
   //do stuff
}
static void funcToDelimitMyOtherFunc()
{
   __asm _emit 0xCC
   __asm _emit 0xCC
   __asm _emit 0xCC
   __asm _emit 0xCC
}

int getlength( void *funcaddress )
{
   int length = 0;
   for(length = 0; *((UINT32 *)(&((unsigned char *)funcaddress)[length])) != 0xCCCCCCCC; ++length);
   return length;
}
```
Es scheint zu funktionieren besser mit statischen Funktionen. Globale Optimierungen können es töten.

P. S. ich hasse Leute, die Fragen, warum Sie dies tun wollen, und es ist unmöglich, etc. Stoppen Sie diese Fragen bitte. Macht Sie blöd klingen. Programmierer sind oft gefragt, um nicht-standard-Sachen, weil die neuen Produkte fast immer die Grenzen dessen, was ist verfügbar. Wenn Sie nicht, Ihr Produkt ist wohl eine Neuauflage dessen, was bereits getan worden. Langweilig!!!
- Hallo Jordan, vielen Dank für diesen klugen (und funktionierende!) Weg, um die Aufgabe zu erfüllen. Ich tatsächlich gelang es, ohne eine zweite statische Funktion, indem man die 0xCCCCCC direkt auf die main-Funktion. Ich hatte eine manuelle Bereinigung des stack via ASM direkt. __asm MOV ESP, EBP __asm POP EBP __asm RETN Zudem die genaue Länge der Funktion, ohne die Platzhalter, die ich geändert ++Länge Länge++
InformationsquelleAutor Jordan
7

Diese wird nicht funktionieren... was wenn es ein Sprung, ein dummy ret, und dann das Sprungziel? Ihr code wird getäuscht werden.

Im Allgemeinen, es ist unmöglich dies mit 100% Genauigkeit, denn Sie müssen Vorhersagen, alle code-Pfade, die ist wie die Lösung der Halteproblem. Erhalten Sie "ziemlich gut" Genauigkeit, wenn Sie bei der Umsetzung Ihrer eigenen disassembler, aber keine Lösung ist fast so einfach wie du dir das vorstellst.

Einen "trick" wäre es, herauszufinden, welche Funktion der code ist nach die Funktion, die du suchst, das wäre ziemlich gute Ergebnisse unter der Annahme bestimmter (gefährlicher) Annahmen. Aber dann müsstest du wissen, welche Funktion kommt nach Ihrer Funktion, die, nach Optimierungen, ist ziemlich schwer herauszufinden.

Edit 1:

Was ist, wenn die Funktion nicht, am Ende sogar mit einem ret Unterricht an alle? Es könnte sehr gut nur jmp an den Aufrufer zurück (obwohl es unwahrscheinlich ist).

Edit 2:

Vergessen Sie nicht, dass x86, zumindest hat die variable-Länge-Anweisungen...

Update:

Für diejenigen, die sagen, dass flow-Analyse ist nicht das gleiche wie die Lösung das Halteproblem:

Überlegen, was passiert, wenn Sie code haben wie:
```
foo:
    ....
    jmp foo
```
Du wird Folgen die springen jedes mal, um herauszufinden, die am Ende der Funktion, und Sie nicht ignorieren, es Vergangenheit das erste mal, weil Sie nicht wissen, ob oder nicht Sie sind den Umgang mit self-modifying code. (Sie können die inline-assembly in den C++ - code, der ändert sich selbst, zum Beispiel.) Es könnte sehr gut erweitern auf eine andere Stelle des Speichers, so dass Ihr Analysator wird (oder sollte) Ende in einer Endlosschleife, es sei denn, Sie tolerieren false negatives.

Ist das nicht wie das Halteproblem?
- Es ist viel möglich, dies zu tun. Sie brauchen nicht zu beweisen, nichts darüber aus, ob eine bestimmte Filiale erreichbar ist -- das ist, was Sie brauchen würde, um das zu lösen Halteproblem für. Die Aufzählung der möglichen code-Pfade ist jedoch-flow-Analyse, die sehr viel tun können.
- Im Grunde würden Sie berechnen die gleiche Weise zyklomatischen Komplexität berechnet.
- Sie müssen beweisen, dass ein bestimmtes Stück code ist nicht erreichbar wenn, Sie nicht? Das scheint ziemlich ähnlich zu dem Halteproblem zu mir...
- NÖ-du bist nur zählen, code-Größe, müssen Sie nur tun-flow-Analyse. Selbst wenn der code nicht erreichbar ist, es ist immer noch ein Teil von der Größe der Funktion. Sie kümmern sich nicht, wenn der code erreichbar ist, Sie nur kümmern, wenn der code vorhanden ist.
- Aber wie wollen Sie unterscheiden, dass es code und keine Daten? Wenn es nicht erreichbar ist, ist es Toten code oder ist es Daten?? Sie müssen beweisen, dass es die Daten, um ausschließen aus der Funktion (oder beweisen, dass es den code, um es), und entweder man ist unmöglich.
- Ich verstehe nicht, warum würden Sie das tun müssen. Eine Funktion beginnt mit einem label und endet mit einem ret. Wir haben den start, so ist es durchaus möglich, alle aufzuzählen, die möglichen Pfade, die in ret s. Dann könnte man entfernen Teile dieser Pfade sind die gleichen, und die Summe der verbleibenden Pfad byte-Längen. Es dauert möglicherweise exponentieller Zeit (in extrem seltenen Fällen), aber es ist nicht incomputeable. (Ich Stimme mit Ihnen überein, dass die OP sollte nicht versuchen, dies zu tun, aber unmöglich ist ein starkes Wort.
- Oh, und wenn ich sage "mögliche Pfade" ich meine "potentiell erreichbar Pfade", D. H. man versucht nicht zu bewerten, ein Sprungbefehl, eine lediglich fest, dass ein Sprungbefehl vorliegt.
- Was, wenn Sie einen jmp statt einer ret obwohl? Niemand sagte, es hat ein Ende mit einem ret... es springen konnte, um ein register-Wert, möglicherweise die Anrufer, oder vielleicht um den code unmittelbar nach sich. Wo kommt also Ihre Funktion Ende genau?
- Ich kenne keinen Compiler der eine jmp zurück. Zwar mag es scheinen, eine sinnvolle Sache, weil der Unterschied in der Semantik zwischen den beiden Anweisungen, es ist generell eine schlechte Idee auf x86 weil es oft bricht der Zweig predictor.
- Sie brauchen nicht zu einem compiler-das bedeutet, dass, nutzen Sie einfach __declspec(naked) - und inline-Montage (oder den Gegenwert in Ihrem compiler).
- Bedenken Sie auch, dass polymorphe Sprünge indirekte Sprünge. Was ist, wenn der compiler geschieht, zu optimieren mit jmp statt ret, und lassen Sie die virtuelle Methode einen Rückgabe statt? Wenn das "Ende" von Ihrer Funktion in diesem Fall?
- Ich nehme an, der OP arbeitet mit vernünftigen code. Wenn man nicht ret dann ja, das problem wird schwer. Ich würde immer noch behaupten nicht unmöglich, aber ich kann nicht mit einem Algorithmus aus der Spitze von meinem Kopf. In Antwort auf Ihre bisschen auf deine Antwort, meine Antwort ist zu sehen, wie die zyklomatische Komplexität berechnet wird -- da der Algorithmus zu tun, die zyklomatische Komplexität ist das gleiche, was ich oben beschreiben. Ihre Schleife Beispiel behandelt wird, indem nicht einem bestimmten Pfad eine Schlaufe bilden.
- loop-Beispiel behandelt wird, indem nicht einem bestimmten Pfad eine Schlaufe bilden. Warum? Es gibt keinen Grund, nicht zu. Wenn Sie feststellen konnten, ob ein Stück code, das erreicht wurde, dann bist du effektiv lösen das Halteproblem. Auch, siehe meinen letzten Kommentar über polymorphe Sprünge, die sind viel mehr "sinnvoll" und durchaus realistisch.
- Mein Punkt ist nicht, dass dies ist nicht eine harte oder unpraktisch problem-es ist schwer und unpraktisch. Aber es ist nicht unmöglich.
- Weil Sie don ' T care, wenn es eine Schleife bildet. Sie möchten nur die Funktion Länge. Wenn Sie jemals eine Schleife, die Sie wissen, haben Sie schon gezählt, die Größe der innerhalb der Schleife, so können Sie es ignorieren. (d.h. Sie können Sie ignorieren, springt die Sprung zurück in der Funktion, denn Sie wollen nur das Ende).
- Wie definieren Sie das Wort "Funktion"? Wenn Sie ihn charakterisieren durch eine ret, dann kann man nie wissen, Wann wirst du erreichen, wenn Sie nach jeder Schleife...
- Nein, tun Sie nicht. Eine bestimmte Funktion kann nicht linear code Weg, aber in Erinnerung, es hat einen Anfang und ein Ende. Wenn Sie einen Sprung, die Funktion vorwärts, wissen Sie, dass alles, was zwischen dem Klick und dem Klick-Ziel ist Teil der Funktion. Wenn Sie einen Sprung rückwärts, Sie wissen schon, die Gegend ist ein Teil der Funktion, so kann diese ignoriert werden. Blick auf die zyklomatische Komplexität. Es löst ein viel schwieriger problem, denn es zählt jeder mögliche Zweig (denn das ist, was die zyklomatische Komplexität ist -- Anzahl der möglichen Pfade durch eine Funktion)
- Sie ignorieren die Möglichkeit der indirekten Sprünge! Wenn Ihr code nie ändert sich, dann würde das funktionieren. Aber indirekte Sprünge-wie die geschieht, in der Polymorphismus-macht dies unmöglich, denn Sie haben keine Ahnung, wo jmp zu, und keine Ahnung, wo Sie weiterhin auf der Suche nach einem ret.
- en.wikipedia.org/wiki/Cyclomatic_complexity <-- Jede größere IDE ich habe gehört, der macht das richtig. Ich finde es schwer zu glauben, etwas ist unmöglich, wenn nicht nur alle tun es, Sie tun es schnell genug, um es in Echtzeit auf dem bearbeiteten code (in den meisten Fällen).
- Ich weiß, was die zyklomatische Komplexität ist, aber was hat das damit zu tun haben? Du bist immer noch nicht mir zu sagen, wie du mit dem Polymorphismus jmp Problem, wenn dein compiler optimiert sich die rets von dem Anrufer.
- Berechnung der zyklomatischen Komplexität findet das Ende der Funktion (nach all-es zu finden ist die Anzahl der Linear unabhängigen Pfade durch die Funktion).
- Sie sind noch nicht mir zu sagen, wie der Polymorphismus Problem behoben ist, Sie scheinen einfach komplett zu ignorieren... 🙁
- +1 Hoppla, ich wollte nicht sehen, wenn ich schrieb mein Kommentar oben (@Billy, @Mehrdad ist richtig, siehe mein Kommentar)
- Indirekte call ist ein Funktionsaufruf, und daher würde nicht in die Auswertung einsteigen.
- Nicht wahr. Als ich erklärte bereits, man würde nicht zu Folgen Pfade, die rückwärts springen. Es wäre hart und unpraktisch, aber nicht unmöglich zu tun. Ich sage nicht, man kann auch einfach die Suche nach einem ret, noch bin ich sagen, dass die OP wird in der Lage sein, so etwas umzusetzen. Ich bin zu sagen, dass dies nicht ein nachweislich incomputable problem. (Wenn Sie produzieren können, ein Beweis dafür, dass ich glücklich sein würde, stand korrigiert, aber zu sagen "ich denke, es ist wie das Halteproblem" oder "hier sind einige Dinge, die es schwer machen," nicht beweisen, dass es incomputable.)
- An Euch beide: Der Beweis für das Halteproblem davon ausgegangen, die Existenz eines Programms, die nicht halt. Hier, wir kümmern uns nicht, wenn das Programm angehalten wird. Wir kümmern uns nicht, wenn eine Filiale erreichbar ist. Wir sind nicht etwas zu tun, mehr als flow-Analyse wie, der umgesetzt wird in den meisten compiler. (Flow-Analyse zu tun hat mit Dingen wie indirekte Anrufe und versaute Anweisungen auch) Die vorgeschlagene problem daher nicht ähnlich ist, das Halteproblem problem. Wenn Sie können, zeigen eine Verringerung, sei mein Gast, aber bis dahin gibt es keinen Grund, darüber zu spekulieren.
- Es ist nicht eine indirekte call, es ist eine indirekte jmp. Soweit ich weiß, das ist nicht eine Funktion aufrufen, jetzt, ist es? (Außerdem: Haben Sie einen Blick auf @BlueRaja Kommentar über die Demontage x86 und wie es sein kann unmöglich?)
- Es ist in der Tat wahr, und ich zeigte bereits einige Codes, die nicht zuverlässig zerlegt (und müssen nicht rückwärts springen). Um dies zu sehen, ersetzen Sie einfach jmp mit jnz; das ist jnz Cont; db 01; Cont: ... Die Frage ist, ist die byte - 0x01 den Anfang einer Anweisung, oder ist die Instruktion, die von der jnz den Anfang von der Anleitung? Vorausgesetzt 0x01 ist nicht ein Befehl von selbst (es ist nicht), und vorausgesetzt, nur ein Pfad wird immer genommen werden, ist der einzige Weg, die Antwort zu wissen, ist zu wissen, welcher Pfad genommen werden; (Fortsetzung..)
- das ist, zu wissen, ob die Berechnung vor der jnz (die kann alles) = 0. Da die Bestimmung der Ausgabe eines beliebigen Programms entspricht dem Halteproblem gibt es keine Möglichkeit, zuverlässig die Frage beantworten.
- Sie brauchen nicht zu zerlegen. Können Sie den code genau wie der Prozessor hat.
- Tut mir Leid, könnten Sie erklären, ein wenig mehr? "Folgenden code genau wie der Prozessor hat" aufgerufen wird das Programm ausgeführt. Abgesehen von der Tatsache, dass Sie das Programm ausführen, um zu bestimmen, den Rückgabewert von einer Funktion ist eine furchtbar ineffiziente Idee, es gibt keine Garantie, dass das Programm wird auch auf call, die der Funktion in diesem Lauf. Und man kann nicht einfach starten Sie das Programm ausführen Anfang an die Funktion in Frage, weil Sie nicht wissen, welche Art von input-Werte, die die Funktion erwartet wird - nicht nur die Funktionsparameter, sondern auch Globale variable states.
- Nein, es ist nicht das Programm ausführen, weil Sie nicht denken, Zweige. Sie sind lediglich das finden der am weitesten möglichen Niederlassung. Sie kümmern sich nicht, wenn die Verzweigung genommen oder nicht genommen wird, Sie nur kümmern, wenn es da ist. Wenn ein Zweig potenziell springt in der Mitte des anderen Anleitung als deiner Analyse könnte widerspiegeln, dass. (d.h., so dass Sie Folgen Sie den Zweig in beide Richtungen)
- Aber das ist das, was ich sage - auch wenn Sie wissen, die Funktion nur ein return-Punkt, wenn die jnz springt in der Mitte einer Anweisung, werden Sie zwei völlig unterschiedliche code-Pfade, die mit (potenziell) zwei verschiedene ret Aussagen. Wie wissen Sie, welche ist die richtige ret (beachte, dass dies nicht immer der "am weitesten ret")? Der einzige Weg, um wissen ist zu wissen, ob die jnz springen wird oder nicht, das ist eines unentscheidbaren Problems.
InformationsquelleAutor Mehrdad
2

Die wirkliche Lösung ist, um zu Graben in Ihre compiler-Dokumentation. Die ARM-Compilers, den wir benutzen werden können, um zu produzieren, eine assembly dump (code.dis), aus denen es ziemlich trivial zu subtrahieren des offsets zwischen einem entstellten-label-Funktion und die nächsten entstellt-label-Funktion.

Ich bin mir nicht sicher, welche Werkzeuge benötigen Sie für diese mit einem windows-Ziel jedoch. Es sieht aus wie die Extras aufgelistet die in der Antwort auf diese Frage könnte das sein, was du bist suchen für.

Beachten Sie auch, dass ich (arbeite im embedded-Bereich) davon ausgegangen, dass Sie redeten über post-compile-Analyse. Es noch möglich sein könnte, zu prüfen, diese intermediate-Dateien programmgesteuert als Teil eines build-vorausgesetzt, dass:
- Die target-Funktion ist in einem anderen Objekt
- Das build-system wurde gelehrt, die Abhängigkeiten
- Sie wissen sicher, dass der compiler bauen diese Objekt-Dateien
Beachten Sie, dass ich bin mir nicht ganz sicher, WARUM Sie wollen, um zu wissen, diese Informationen. Ich habe dies in der Vergangenheit gebraucht, um sicher zu sein, dass ich passen einer bestimmten Stück code in einem ganz bestimmten Ort im Speicher. Ich muss zugeben, ich bin neugierig, welchen Zweck dies hätte über eine Allgemeine desktop-OS Ziel.

InformationsquelleAutor jkerian
2

Diese kann Arbeit in sehr begrenzten Szenarien. Ich benutze es im Rahmen eines code-injection-Dienstprogramm, das ich schrieb. Ich weiß nicht, wo ich die Informationen gefunden, aber ich habe Folgendes (C++ in VS2005):
```
#pragma runtime_checks("", off)

static DWORD WINAPI InjectionProc(LPVOID lpvParameter)
{
    //do something
    return 0;
}

static DWORD WINAPI InjectionProcEnd()
{
    return 0;
}

#pragma runtime_checks("", on)
```
Und dann in eine andere Funktion, die ich habe:
```
size_t cbInjectionProc = (size_t)InjectionProcEnd - (size_t)InjectionProc;
```
Haben Sie zum ausschalten einige Optimierungen und erklären die Funktionen als static zu bekommen, diese Arbeit; ich erinnere mich nicht, die Besonderheiten. Ich weiß nicht, ob dies ist eine genaue byte-Anzahl, aber es ist nahe genug. Die Größe ist nur, dass der unmittelbare Funktion; es sind keine anderen Funktionen, die aufgerufen werden können, von dieser Funktion. Abgesehen vom extremen Rand Fälle wie diese, "die Größe einer Funktion" ist sinnlos und nutzlos.
- Zwei Korrekturen und eine Warnung hier: 1) ich möchte hinzufügen __declspec(noinline) zu der Methode, Erklärungen zu verhindern inlining in einem release bauen. 2) Es sollte #pragma runtime_checks("", restore) statt on 3) Warnung:, Wenn Sie planen, die Injektion dieser Methode in einen separaten Prozess, das wird Absturz es, wenn Ihr InjectionProc Methode hat alle statisch verbundenen API-Aufrufe.
InformationsquelleAutor Luke
1

In C++, die gibt es keine Vorstellung von Funktion, Größe. Zusätzlich zu allem anderen erwähnt, Präprozessor-Makros auch machen, für eine unbestimmte Größe. Wenn Sie wollen zählt die Anzahl Unterricht Worten, Sie können das nicht in C++, weil es nicht existiert, bis es kompiliert wurde.
- Das war der Punkt, der mit einem Zeiger. (kein Wortspiel beabsichtigt) Mein Ziel ist es, die Anzahl der bytes, die der Computer-code, der Funktion im Arbeitsspeicher.
InformationsquelleAutor Zach Rattner
1

Was meinst du mit "Größe einer Funktion"?

Wenn du meinst eine Funktion Zeiger, als es immer nur 4 bytes für 32-bit-Systeme.

Wenn du meinst die Größe des Codes haben, als Sie sollten einfach zerlegen generierten code und finden Sie den Einstiegspunkt und am nächsten ret nennen. Ein Weg, es zu tun, ist zu Lesen, das instruction-pointer-register am Anfang und am Ende der Funktion.

Wenn Sie möchten, um herauszufinden, die Anzahl von Anweisungen aufgerufen, in der durchschnittlichen Fall für Ihre Funktion, die Sie verwenden können, Profiler und teilen Sie die Anzahl von pensionierten Anweisungen auf der Anzahl der Anrufe.

InformationsquelleAutor Elalfer
1

Ich denke, es funktioniert auf windows-Programme erstellt, die mit msvc, als für die Zweige der 'ret' scheint immer am Ende (auch wenn es Zweige, die Rückkehr Anfang tut es ein jne zu gehen, am Ende).
Sie brauchen jedoch eine Art disassembler-Bibliothek zur Abbildung der aktuellen opcode-Länge, wie Sie variabler Länge für x86. Wenn Sie dies nicht tun, du wirst laufen in der false-positives.

Ich würde mich nicht Wundern, wenn es Fälle gibt, dies nicht zu fangen.

InformationsquelleAutor Michael Chinen
1

Gibt es keine Einrichtungen, die in Standard-C++ zu erhalten, die Größe oder Länge einer Funktion.

Siehe meine Antwort hier: Ist es möglich zum laden einer Funktion in eine zugeordnete Speicher und von dort aus ausgeführt?

Im Allgemeinen, zu wissen, die Größe einer Funktion ist die Verwendung in embedded-Systemen beim kopieren von ausführbaren code aus einem nur-lese-Quelle (oder eine langsame Speicher-Gerät, wie z.B. einem seriellen Flash) ins RAM. Desktop und anderen Betriebssystemen load-Funktionen in den Speicher mit anderen Techniken, wie dynamische oder gemeinsam genutzte Bibliotheken.

InformationsquelleAutor Thomas Matthews
1

Nur gesetzt, PAGE_EXECUTE_READWRITE an die Adresse, wo Sie bekam Ihre Funktion. Dann Lesen jedes byte. Wenn du byte "0xCC" es bedeutet, dass das Ende der Funktion ist actual_reading_address - 1.

InformationsquelleAutor MrOMGWTF
1

Ich bin dieses posting, um zwei Dinge zu sagen:

1) die Meisten Antworten, die hier gegeben sind wirklich schlecht und wird leicht brechen. Wenn Sie die C-Funktion einen Zeiger (mit name der Funktion), die in einem debug bauen Sie die ausführbare Datei, und möglicherweise auch in anderen Fällen kann es zu einem Punkt JMP shim, die nicht die Funktion haben Körper selbst. Hier ist ein Beispiel. Wenn ich den folgenden Code für die Funktion, die ich unten definiert:
```
FARPROC pfn = (FARPROC)some_function_with_possibility_to_get_its_size_at_runtime;
```
den pfn ich bekomme (zum Beispiel: 0x7FF724241893) wird zeigen, was nur ein JMP Anleitung:

Zusätzlich ein compiler kann nest mehrere von diesen Scheiben, oder Zweig Ihrer Funktion code so, dass es mehrere Epiloge, oder ret Anweisungen. Was solls, es kann nicht einmal mit einem ret Unterricht. Dann, es gibt keine Garantie, dass die Funktionen selbst kompiliert und verlinkt werden, in der Reihenfolge, die Sie definieren, Sie in den source-code.

Können Sie all das Zeug in Montage Sprache, aber nicht in C oder C++.

2), So dass oben war die schlechte Nachricht. Die gute Nachricht ist, dass die Antwort auf die ursprüngliche Frage ist, ja, es gibt einen Weg, (oder ein hack), um die genaue Funktion der Größe, aber es kommt mit den folgenden Einschränkungen:
- Es funktioniert in der 64-bit-Programme nur für Windows.
- Es offensichtlich ist Microsoft-spezifisch und nicht portierbar.
- Muss man dies bei der Laufzeit.
Das Konzept ist einfach-nutzen Sie die Möglichkeit SEH umgesetzt wird in der x64-Windows-Binärdateien. Compiler fügt die details zu jeder Funktion in der PE32+ header (in der IMAGE_DIRECTORY_ENTRY_EXCEPTION Verzeichnis der optional header), die Sie verwenden können, erhalten Sie die genaue Funktion der Größe. (Falls Sie sich Wundern, diese information wird verwendet für den Fang, die Handhabung und abwickeln von Ausnahmen in der __try/__except/__finally Blöcke.)

Hier ein kurzes Beispiel:
```
//You will have to call this when your app initializes and then
//cache the size somewhere in the global variable because it will not
//change after the executable image is built.

size_t fn_size; //Will receive function size in bytes, or 0 if error
some_function_with_possibility_to_get_its_size_at_runtime(&fn_size);
```
dann:
```
#include <Windows.h>

//The function itself has to be defined for two types of a call:
//1) when you call it just to get its size, and
//2) for its normal operation
bool some_function_with_possibility_to_get_its_size_at_runtime(size_t* p_getSizeOnly = NULL)
{
    //This input parameter will define what we want to do:
    if(!p_getSizeOnly)
    {
        //Do this function's normal work
        //...

        return true;
    }
    else
    {
        //Get this function size
        //INFO: Works only in 64-bit builds on Windows!
        size_t nFnSz = 0;

        //One of the reasons why we have to do this at run-time is
        //so that we can get the address of a byte inside 
        //the function body... we'll get it as this thread context:
        CONTEXT context = {0};
        RtlCaptureContext(&context);

        DWORD64 ImgBase = 0;
        RUNTIME_FUNCTION* pRTFn = RtlLookupFunctionEntry(context.Rip, &ImgBase, NULL);
        if(pRTFn)
        {
            nFnSz = pRTFn->EndAddress - pRTFn->BeginAddress;
        }

        *p_getSizeOnly = nFnSz;
        return false;
    }
}
```
InformationsquelleAutor ahmd0
0

GCC verwenden, gar nicht so schwer.
```
void do_something(void) { 
   printf("%s!", "Hello your name is Cemetech"); 
   do_something_END: 
} 

... 

   printf("size of function do_something: %i", (int)(&&do_something_END - (int)do_something));
```
- Ist dies garantiert, um genau zu sein? Ich glaube nicht, dass der compiler garantiert nichts über die Reihenfolge der Anweisungen innerhalb einer Funktion.
- Zunächst scheint es, müssen Sie eine Anweisung nach dem label, und zweitens das funktioniert nicht, wenn Sie müssen &&do_something_END verfügbar im Datei-Bereich, so dass es mehr oder weniger nutzlos.
InformationsquelleAutor Ashbad Ruffa

folgenden code der die genaue Funktion der Blockgröße, es funktioniert gut mit meinem test
runtime_checks deaktivieren _RTC_CheckEsp im debug-Modus

    #pragma runtime_checks("", off)
DWORD __stdcall loadDll(char* pDllFullPath)
{  
    OutputDebugStringA(pDllFullPath);
    //OutputDebugStringA("loadDll...................\r\n");
    return 0;
    //return test(pDllFullPath);
}
#pragma runtime_checks("", restore)

DWORD __stdcall getFuncSize_loadDll()
{
    DWORD maxSize=(PBYTE)getFuncSize_loadDll-(PBYTE)loadDll;
    PBYTE pTail=(PBYTE)getFuncSize_loadDll-1;
    while(*pTail != 0xC2 && *pTail != 0xC3) --pTail;
    if (*pTail==0xC2)
    {   //0xC3          : ret
        //0xC2 04 00    : ret 4
        pTail +=3;
    }

    return pTail-(PBYTE)loadDll;
};

InformationsquelleAutor Shen Tony

0

Die nicht-portable, aber API-basierte und korrekt funktionierenden Ansatz ist die Verwendung von Programm-Datenbank - Reader- wie dbghelp.dll auf Windows oder auf Linux-readelf. Die Nutzung dieser ist nur möglich, wenn debug-Informationen aktiviert/vorhanden zusammen mit dem Programm. Hier ist ein Beispiel, wie es funktioniert auf Windows:
```
SYMBOL_INFO symbol = { };

symbol.SizeOfStruct = sizeof(SYMBOL_INFO);

//Implies, that the module is loaded into _dbg_session_handle, see ::SymInitialize & ::SymLoadModule64
::SymFromAddr(_dbg_session_handle, address, 0, &symbol);
```
Erhalten Sie die Größe der Funktion in symbol.Größe, aber Sie müssen möglicherweise auch zusätzliche Logik zu identifizieren, ob die angegebene Adresse ist eigentlich eine Funktion, ein shim platziert es durch inkrementelle linker oder ein DLL-Aufruf thunk (gleiche Sache).

Ich denke, etwas ähnliches kann über readelf auf Linux, aber vielleicht haben Sie zu kommen mit der Bibliothek, auf der Oberseite der sourcecode...

Müssen Sie Bedenken, dass, obwohl die Demontage-basierten Ansatz möglich ist, Sie grundsätzlich zu analysieren, gerichteter graph mit Endpunkten in ret, halt, jmp (VORAUSGESETZT, Sie haben inkrementellen Verknüpfung aktiviert, und Sie sind in der Lage zu Lesen jmp-Tabelle, um festzustellen, ob der jmp-Sie sind mit in der Funktion ist die interne Funktion (fehlt im Bild die jmp-Tabelle) oder externe (in diesem Tisch; eine solche jmps Häufig auftreten, als Teil der tail-call-Optimierung auf x64, ich weiß)), alle Anrufe, die gemeint sind, zu nonret (wie eine Ausnahme generieren Helfer), etc.

InformationsquelleAutor Arty
0

Es ist eine alte Frage, aber trotzdem...

Für Windows x64, alle Funktionen haben eine Funktion Tabelle, die enthält den offset und die Größe der Funktion. https://docs.microsoft.com/en-us/windows/win32/debug/pe-format . Diese Funktion Tabelle wird verwendet, um zu entspannen, wenn eine Ausnahme geworfen wird.

Sagte, dass dies nicht die Informationen enthalten, wie inlining, und alle anderen Themen, die die Menschen schon angemerkt...

InformationsquelleAutor atlaste

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Update: