verilator_bin_dbg - En ligne dans le Cloud

PROGRAMME:

Nom

Verilator - Convertir le code Verilog en C++/SystemC

SYNOPSIS

vérificateur --help
vérificateur --version
verilator --cc [options] [top_level.v]... [opt_c_files.cpp/c/cc/a/o/so]
verilator --sc [options] [top_level.v]... [opt_c_files.cpp/c/cc/a/o/so]
verilator --lint-only [top_level.v]...

DESCRIPTION

Verilator convertit le code Verilog synthétisable (non comportemental), ainsi que certains Synthesis,
SystemVerilog et un petit sous-ensemble d'assertions Verilog AMS, en code C++ ou SystemC. Ce
n'est pas un simulateur complet, mais un compilateur.

Verilator est invoqué avec des paramètres similaires à GCC, Cadence Verilog-XL/NC-Verilog ou
VCS de Synopsys. Il lit le code Verilog spécifié, le lit et ajoute éventuellement
couverture et code de traçage de forme d'onde. Pour les formats C++ et SystemC, il génère .cpp et .h
fichiers.

Les fichiers créés par Verilator sont ensuite compilés avec C++. L'utilisateur écrit un peu de C++
wrapper, qui instancie le module de niveau supérieur, et passe ce nom de fichier sur le
ligne de commande. Ces fichiers C sont compilés en C++ et liés aux fichiers vérifiés.

L'exécutable résultant effectuera la simulation réelle.

Pour commencer, passez à "EXEMPLE D'EXECUTION C++".

ARGUMENT RÉSUMÉ

Ceci est un bref résumé des arguments à Verilator. Voir les descriptions détaillées dans
les sections suivantes pour plus d'informations.

{file.v} Noms de fichiers de niveau supérieur Verilog
{file.c/cc/cpp} Fichiers C++ facultatifs à compiler
{file.a/o/so} Fichiers C++ facultatifs à lier

+1364-1995ext+ Utilisez Verilog 1995 avec l'extension de fichier
+1364-2001ext+ Utilisez Verilog 2001 avec l'extension de fichier
+1364-2005ext+ Utilisez Verilog 2005 avec l'extension de fichier
+1800-2005poste+ Utilisez SystemVerilog 2005 avec l'extension de fichier
+1800-2009poste+ Utilisez SystemVerilog 2009 avec l'extension de fichier
+1800-2012poste+ Utilisez SystemVerilog 2012 avec l'extension de fichier
--assert Activer toutes les assertions
--autoflush Vide les flux après tous les affichages $
--bbox-sys Blackbox inconnu $ appels système
--bbox-unsup Fonctionnalités linguistiques non prises en charge par Blackbox
--poubelle Remplacer le binaire Verilator
-FLAGS Indicateurs du compilateur C++ pour makefile
--cc Créer une sortie C++
--cdc Analyse de croisement de domaine d'horloge
--clk Marquer le signal spécifié comme horloge
--compilateur Réglage pour le compilateur C++ spécifié
--converge-limite Régler le temps de stabilisation de la convergence
--coverage Activer toutes les couvertures
--coverage-line Activer la couverture de ligne
--coverage-toggle Activer basculer la couverture
--coverage-user Activer la couverture des utilisateurs SVL
--coverage-underscore Activer la couverture des _signaux
-D [= ] Définir la définition du préprocesseur
--debug Activer le débogage
--debug-check Activer les assertions de débogage
--debugi Activer le débogage à un niveau spécifié
--debugi- Activer le débogage d'un fichier source à un niveau
--langage par défaut Langue par défaut à analyser
+définir+ = Définir la définition du préprocesseur
--dump-tree Activer le vidage des fichiers .tree
--dump-treei Activer le vidage des fichiers .tree à un niveau
--dump-treei- Activer le vidage du fichier .tree dans un fichier source à un niveau
-E Prétraite, mais ne compile pas
--error-limit Abandonner après ce nombre d'erreurs
--exe Lien pour créer l'exécutable
-F Analyser les options d'un fichier, relativement
-F Options d'analyse à partir d'un fichier
--gdb Exécuter Verilator sous GDB de manière interactive
--gdbbt Exécuter Verilator sous GDB pour le backtrace
--help Afficher cette aide
-JE Répertoire à rechercher comprend
--if-profondeur Régler l'avertissement IFDEPTH
+incdir+ Répertoire à rechercher comprend
--inhibit-sim Créer une fonction pour désactiver la simulation
--inline-mult Tune module inlining
-LDFLAGS Indicateurs de pré-objet de l'éditeur de liens pour makefile
-LDLIBS Indicateurs de bibliothèque de liens pour makefile
--Langue Norme de langue par défaut à analyser
+libext+ +[ext]... Extensions pour trouver des modules
--lint-only Lint, mais ne fait pas de sortie
--MMD Créer des fichiers de dépendance .d
--MP Créer de fausses cibles de dépendance
--Mdir Nom du répertoire de l'objet de sortie
--mod-prefix Nom à ajouter aux classes inférieures
--no-clk Empêcher le marquage du signal spécifié comme horloge
--no-pins64 Ne pas utiliser vluint64_t pour les signatures 33-64 bits
--no-skip-identical Désactiver le saut de sortie identique
+notingchecks ignoré
-O0 Désactiver les optimisations
-O3 Optimisations hautes performances
-O Optimisations sélectionnables
-o Nom de l'exécutable final
--no-order-clock-delay Désactiver les affectations d'activation de l'horloge de commande
--sortie-split Divisez les fichiers .cpp en morceaux
--output-split-cfuncs Fractionner les fonctions .cpp
--output-split-ctrace Fonctions de traçage fractionnées
-P Désactiver les numéros de ligne et les blancs avec -E
--pins-bv Spécifier les types de ports de niveau supérieur
--pins-sc-uint Spécifiez les types pour les ports de niveau supérieur
--pins-sc-biguint Spécifier les types pour les ports de niveau supérieur
--pins-uint8 Spécifie les types pour les ports de niveau supérieur
--pipe-filtre Filtrer toutes les entrées via un script
--préfixe Nom de la classe de niveau supérieur
--profile-cfuncs Nommer les fonctions pour le profilage
--Débogage privé ; voir la doc
--débogage public ; voir la doc
--report-unoptflat Diagnostics supplémentaires pour UNOPTFLAT
--savable Activer la sauvegarde-restauration du modèle
--sc Créer une sortie SystemC
--stats Créer un fichier de statistiques
--stats-vars Fournit des statistiques sur les variables
-sv Activer l'analyse SystemVerilog
+systemverilogext+ Synonyme de +1800-2012ext+
--top-module Nom du module d'entrée de niveau supérieur
--trace Activer la création de forme d'onde
--trace-profondeur Profondeur de traçage
--trace-max-array Largeur de bits maximale pour le traçage
--trace-max-largeur Profondeur maximale du tableau pour le traçage
--trace-params Activer les paramètres de traçage
--trace-structs Activer le suivi des noms de structure
--trace-underscore Activer le traçage de _signals
-U Undefine définition du préprocesseur
--unroll-count Ajuster le nombre maximal d'itérations de boucle
--unroll-stmts Régler la taille maximale du corps de la boucle
--unused-regexp Réglez les signaux de charpie INUTILISÉS
-V Verbose version et configuration
-v Bibliothèque Verilog
+verilog1995ext+ Synonyme de +1364-1995ext+
+verilog2001ext+ Synonyme de +1364-2001ext+
-Werreur- Convertir l'avertissement en erreur
-Wavenir- Désactiver les avertissements de message inconnu
-Wno- Désactiver l'avertissement
-Wno-lint Désactiver tous les avertissements de peluches
-Wno-style Désactiver tous les avertissements de style
-Wno-fatal Désactiver la sortie fatale sur les avertissements
--x-assign Affectez initialement Xs à cette valeur
--x-initial-edge Active les déclencheurs de front X->0 et X->1 initiaux
-y Répertoire pour rechercher des modules

ARGUMENTS

{fichier.v}
Spécifie le fichier Verilog contenant le module supérieur à vérifier.

{fichier.c/.cc/.cpp/.cxx}
Spécifie les fichiers C++ facultatifs à lier avec le code Verilog. Si des fichiers C++
sont spécifiés de cette manière, Verilator inclura une règle make qui génère un module
exécutable. Sans aucun fichier C++, Verilator s'arrêtera au module__ALL.a bibliothèque,
et présumez que vous continuerez à créer des liens avec les règles que vous écrivez vous-même. Voir aussi le
-Option FLAG.

{fichier.a/.o/.so}
Spécifie les fichiers d'objet ou de bibliothèque facultatifs à lier avec le code Verilog, en tant que
raccourci pour -LDFLAGS " ". Si des fichiers sont spécifiés de cette manière, Verilator
inclura une règle make qui utilise ces fichiers lors de la liaison du module exécutable
Ceci n'est généralement utile que lorsqu'il est utilisé avec l'option --exe.

+1364-1995poste+poste
+1364-2001poste+poste
+1364-2005poste+poste
+1800-2005poste+poste
+1800-2009poste+poste
+1800-2012poste+poste
Spécifie la norme de langue à utiliser avec une extension de nom de fichier spécifique, poste.

Pour la compatibilité avec d'autres simulateurs, voir aussi les synonymes "+verilog1995ext+"poste,
"+verilog2001ext+"poste, et "+systemverilogext+"poste.

Pour tout fichier source, la langue spécifiée par ces options prévaut sur toute
langue spécifiée par les options "--default-language" ou "--language".

Ces options prennent effet dans l'ordre dans lequel elles sont rencontrées. Ainsi ce qui suit serait
utilisez Verilog 1995 pour "av" et Verilog 2001 pour "bv".

verilator ... +1364-1995ext+v av +1364-2001ext+v bv

Ces indicateurs ne sont recommandés que pour les conceptions de langage mixte héritées, car il est préférable
l'option est de modifier le code pour réparer de nouveaux mots-clés, ou d'ajouter les
"`begin_keywords".

Notes "`begin_keywords" est une construction SystemVerilog, qui spécifie uniquement ce en quoi consistera l'
ensemble de mots-clés doit être reconnu. Quel que soit l'ensemble choisi, la sémantique sera
ceux de SystemVerilog. En revanche, "+1364-1995ext+" etc. spécifiez à la fois la syntaxe et
sémantique à utiliser.

--affirmer
Activez toutes les assertions.

Voir aussi --x-assign et --x-initial-edge ; paramètre "--x-assign unique" et/ou
"--x-initial-edge" peut être souhaitable.

--flush automatique
Après chaque $display ou $fdisplay, videz le flux de sortie. Cela assure que
les messages apparaîtront immédiatement mais peuvent réduire les performances ; pour la meilleure performance appel
"fflush(stdout)" occasionnellement dans la boucle C principale. Par défaut désactivé, ce qui mettra en mémoire tampon
sortie telle que fournie par les appels normaux C stdio.

--bbox-sys
Boîte noire de tout appel de tâche ou de fonction $ système inconnu. Les tâches système seront simplement
NOPed, et les fonctions système seront remplacées par zéro non dimensionné. Des arguments à de tels
les fonctions seront analysées, mais pas vérifiées autrement. Cela évite les erreurs lorsque
linting en présence d'appels PLI spécifiques à l'entreprise.

--bbox-unsup
Boîte noire certaines fonctionnalités linguistiques non prises en charge, actuellement les tables UDP et les cmos et
primitives de porte tran. Cela peut permettre de pelucher le reste de la conception même lorsque
des constructions non prises en charge sont présentes.

--poubelle nom de fichier
Rarement nécessaire. Remplacez le nom de fichier par défaut pour Verilator lui-même. Lorsqu'une dépendance
(.d) est créé, ce nom de fichier deviendra une dépendance source, de sorte qu'un
le changement dans ce binaire aura fait reconstruire les fichiers de sortie.

-FLAGS drapeaux
Ajoutez les indicateurs de compilateur C spécifiés aux makefiles générés. Lorsque make est exécuté sur le
makefile généré, ceux-ci seront transmis au compilateur C++ (gcc/g++/msvc++).

--cc
Spécifie C++ sans le mode de sortie SystemC ; voir aussi --sc.

--CDC
Expérimental. Effectuer des vérifications de croisement de domaine d'horloge et émettre des avertissements liés
(CDCRSTLOGIC) puis sortie ; si des avertissements autres que les avertissements CDC sont nécessaires, faites un
deuxième exécution avec --lint-only. Des informations d'avertissement supplémentaires sont également écrites sur le
fichier {préfixe}__cdc.txt.

Ne vérifie actuellement que certains éléments que d'autres outils CDC ont manqués ; si vous avez un intérêt pour
en ajoutant des contrôles CDC plus traditionnels, veuillez contacter les auteurs.

--clk nom-signal
Parfois, il est assez difficile pour Verilator de distinguer les signaux d'horloge des autres
signaux de données. Parfois, les signaux d'horloge peuvent se retrouver dans la liste de contrôle de
signaux qui déterminent si une évaluation supplémentaire est nécessaire. Cela va fortement se dégrader
la performance du modèle vérifié.

Avec --clk , l'utilisateur peut spécifier l'horloge racine dans le modèle, puis Verilator
marquera le signal comme horloger et propagera automatiquement l'attribut horloger à
d'autres signaux dérivés de cela. De cette façon, Verilator essaiera d'éviter de prendre les
signal d'horloge dans la liste de contrôle.

Notez que le nom-signal est spécifié par le chemin de hiérarchie RTL. Par exemple, v.foo.bar. Si
le signal est l'entrée du module supérieur, directement le nom du signal. Si vous le trouvez
difficile de trouver le nom exact, essayez d'utiliser "/*verilator clocker*/" dans le fichier RTL pour
marquer le signal directement.

--compilateur nom-compilateur
Active les réglages et les solutions de contournement pour le compilateur C++ spécifié.

bruit
Accordez pour le bruit. Cela peut réduire la vitesse d'exécution car cela permet plusieurs solutions de contournement
pour éviter les limites stupides codées en dur dans clang. Cela inclut la rupture de structures profondes
comme pour msvc comme décrit ci-dessous.

gcc Tune pour Gnu C++, bien que le code généré devrait fonctionner sur presque tous les C++ conformes
compilateur. Actuellement la valeur par défaut.

msvc
Accordez-vous pour Microsoft Visual C++. Cela peut réduire la vitesse d'exécution car cela permet
plusieurs solutions de contournement pour éviter les limites stupides codées en dur dans MSVC++. Ceci comprend
briser les expressions entre parenthèses profondément imbriquées en sous-expressions pour éviter
erreur C1009 et diviser les blocs profonds en fonctions pour éviter l'erreur C1061.

--converge-limite
Rarement nécessaire. Spécifie le nombre maximal d'itérations d'exécution avant de créer un
le modèle n'a pas réussi à converger erreur. La valeur par défaut est 100.

--couverture
Active toutes les formes de couverture, alias pour "--coverage-line --coverage-toggle
--couverture-utilisateur".

--couverture-ligne
Spécifie que le code d'analyse de couverture de ligne de bloc de base doit être inséré.

L'analyse de couverture ajoute des instructions à chaque point de changement de flux de code, qui sont les
branches des instructions IF et CASE, un super-ensemble de couverture de ligne Verilog normale. À
pour chacune de ces branches, un compteur unique est incrémenté. A la fin d'un test, les compteurs
ainsi que le nom de fichier et le numéro de ligne correspondant à chaque compteur sont écrits dans
logs/couverture.pl.

Verilator désactive automatiquement la couverture des branches contenant un $stop, car il
est supposé que les branches $stop contiennent une vérification d'erreur qui ne devrait pas se produire. Un /*vérificateur
coverage_block_off*/comment effectuera une fonction similaire sur n'importe quel code de ce bloc
ou en dessous, ou /*verilatorcoverage_on/coverage_off*/ désactivera la couverture autour des lignes
du code.

Remarque Verilator peut surcompter les blocs combinatoires (non cadencés) lorsque ces blocs
recevoir des signaux pour lesquels l'avertissement UNOPTFLAT a été désactivé ; pour le plus précis
les résultats ne désactivent pas cet avertissement lors de l'utilisation de la couverture.

--couverture-toggle
Spécifie que le code d'analyse de couverture de basculement de signal doit être inséré.

Chaque bit de chaque signal dans un module a un compteur inséré. Le compteur va
incrément à chaque changement de front du bit correspondant.

Les signaux qui font partie des tâches ou des blocs de début/fin sont considérés comme des variables locales et
ne sont pas couverts. Les signaux qui commencent par des traits de soulignement, sont des nombres entiers ou sont très larges
(> 256 bits de stockage total dans toutes les dimensions) ne sont pas non plus couverts.

La hiérarchie est compressée, de sorte que si un module est instancié plusieurs fois,
la couverture sera additionnée pour ce bit sur TOUTES les instanciations de ce module avec le
même jeu de paramètres. Un module instancié avec différentes valeurs de paramètres est
considéré comme un module différent et sera compté séparément.

Verilator prend une décision peu intelligente sur le domaine d'horloge du signal
va à, et ne recherche que les bords dans ce domaine d'horloge. Cela signifie que les bords peuvent être
ignoré s'il est connu que le bord ne pourrait jamais être vu par la logique de réception. Cette
l'algorithme peut s'améliorer à l'avenir. Le résultat net est que la couverture peut être inférieure à
ce qui serait vu en regardant les traces, mais la couverture est plus précise
représentation de la qualité du stimulus dans la conception.

Il peut y avoir des arêtes comptées près du temps zéro pendant que le modèle se stabilise. C'est bien
s'entraîner à remettre à zéro toute la couverture juste avant de relâcher la réinitialisation pour éviter de compter de tels
comportement.

Une paire de commentaires /*verilatorcover_off/on */ peut être utilisée autour des signaux qui ne
besoin d'une analyse à bascule, comme les RAM et les fichiers de registre.

--couverture-trait de soulignement
Activez la couverture des signaux commençant par un trait de soulignement. Normalement, ces signaux sont
non couvert. Voir aussi --trace-underscore.

--couverture-utilisateur
Active la couverture fonctionnelle insérée par l'utilisateur. Actuellement, tous les points de couverture fonctionnels
sont spécifiés à l'aide de SVA qui doit être activé séparément avec --assert.

Par exemple, l'instruction suivante ajoutera un point de couverture, avec le commentaire
"DefaultClock":

DefaultClock : propriété de couverture (@(posedge clk) cyc==3) ;

-Dvar=Plus-value
Définit le symbole de préprocesseur donné, sans l'autoriser. Similaire à +define ; +définir
est assez standard pour les outils Verilog tandis que -D est un alias pour la compatibilité GCC.

--déboguer
Sélectionnez l'image de débogage de Verilator (si disponible) et activez plus d'images internes
assertions (équivalent à "--debug-check"), messages de débogage (équivalent à
"--debugi 4"), et des fichiers de vidage de forme intermédiaire (équivalent à "--dump-treei 3").

--debug-check
Rarement nécessaire. Activer les vérifications d'assertion de débogage internes, sans modifier le débogage
verbosité. Activé automatiquement lorsque --debug est spécifié.

--debugi
--debugi-
Rarement nécessaire - pour une utilisation par les développeurs. Définissez le niveau de débogage interne globalement sur le
niveau de débogage spécifié (1-10) ou définissez le fichier source Verilator spécifié sur le
niveau spécifié (par exemple "--debugi-V3Width 9"). Des niveaux plus élevés produisent plus de détails
des messages.

--langage par défaut Plus-value
Sélectionnez la langue à utiliser par défaut lors du premier traitement de chaque fichier Verilog.
La valeur de la langue doit être "1364-1995", "1364-2001", "1364-2005", "1800-2005",
"1800-2009" ou "1800-2012".

Toute langue associée à une extension de fichier particulière (voir les différents +longposte+
options) sera utilisé de préférence à la langue spécifiée par --default-language.

L'indicateur --default-language n'est recommandé que pour le code hérité utilisant le même
langue dans tous les fichiers source, car l'option préférable est d'éditer le code à réparer
de nouveaux mots-clés ou ajoutez les "`begin_keywords" appropriés. Pour les conceptions en langage mixte héritées,
les divers +longLes options ext+ doivent être utilisées.

Si aucune langue n'est spécifiée, soit par ce drapeau soit +longext+ options, puis la dernière
Le langage SystemVerilog (IEEE 1800-2012) est utilisé.

+définir+var=Plus-value
+définir+var=Plus-value+var2=value2
Définit le symbole de préprocesseur donné, ou plusieurs symboles s'ils sont séparés par des plus.
Similaire à -D ; +define est assez standard pour les outils Verilog tandis que -D est un alias
pour la compatibilité GCC.

--dump-arbre
Rarement nécessaire. Activez l'écriture des fichiers de débogage .tree avec le niveau de vidage 3, qui vide le
étapes critiques standard. Pour plus de détails sur le format, voir Verilator Internals
Manuel. --dump-tree est activé automatiquement avec --debug, donc "--debug
--no-dump-tree" peut être utile si les fichiers de vidage sont volumineux et indésirables.

--dump-treei
--dump-treei-
Rarement nécessaire - pour une utilisation par les développeurs. Définir le niveau de vidage de l'arborescence interne globalement sur un
niveau de vidage spécifique ou définissez le fichier source Verilator spécifié sur le
niveau de vidage de l'arbre (par exemple "--dump-treei-V3Order 9"). Le niveau 0 désactive les vidages et est
équivalent à "--no-dump-tree". Le niveau 9 permet le dumping de chaque étape.

-E Prétraite le code source, mais ne compile pas, comme avec 'gcc -E'. La sortie est écrite
à la sortie standard. Méfiez-vous de l'activation des messages de débogage, car ils iront également à
sortie standard.

--error-limit
Une fois ce nombre d'erreurs ou d'avertissements rencontrés, quittez. La valeur par défaut est 50.

--EXE
Générez un exécutable. Vous devrez également transmettre des fichiers .cpp supplémentaires sur le
ligne de commande qui implémente la boucle principale de votre simulation.

-F filet
Lire le fichier spécifié et agir comme si tout le texte qu'il contient était spécifié en tant que commande
paramètres de ligne. Tous les chemins relatifs sont relatifs au répertoire contenant le
fichier spécifié. Voir aussi -f. Remarque -F est assez standard parmi les outils Verilog.

-f filet
Lire le fichier spécifié et agir comme si tout le texte qu'il contient était spécifié en tant que commande
paramètres de ligne. Tous les chemins relatifs sont relatifs au répertoire courant. Voir également
-F. Remarque -f est assez standard pour tous les outils Verilog.

Le fichier peut contenir // des commentaires qui sont ignorés jusqu'à la fin de la ligne. Tout $VAR,
$(VAR) ou ${VAR} sera remplacé par la variable d'environnement spécifiée.

--gdb
Exécutez Verilator sous une GDB interactive (ou une variable d'environnement VERILATOR_GDB
valeur) session. Voir aussi --gdbbt.

--gdbbt
Si --debug est spécifié, exécutez Verilator sous un processus GDB et imprimez une trace
à la sortie, puis quitter GDB immédiatement. Sans --debug ou si GDB ne semble pas fonctionner,
ce drapeau est ignoré. Destiné à la création facile de backtraces par les utilisateurs ; autrement
voir l'indicateur --gdb.

--Aidez-moi
Affiche ce message et la version du programme et quitte.

-Idir
Voir -y.

--if-profondeur Plus-value
Rarement nécessaire. Définissez la profondeur à laquelle l'avertissement IFDEPTH se déclenchera, la valeur par défaut est 0
qui désactive cet avertissement.

+indiquer+dir
Voir -y.

--inhiber-sim
Rarement nécessaire. Créez une fonction "inhibitSim(bool)" pour activer et désactiver l'évaluation.
Cela permet à un banc d'essai de niveau supérieur de désactiver les modules qui ne sont pas importants dans un
simulation donnée, sans avoir besoin de recompiler ou de modifier les modules SystemC
instancié.

--inline-multi Plus-value
Réglez l'inlining des modules. La valeur par défaut de 2000 spécifie que jusqu'à 2000 nouveaux
opérations peuvent être ajoutées au modèle par inline, si plus que ce nombre de
des opérations en résulteraient, le module n'est pas en ligne. Des valeurs plus grandes, ou une valeur <= 1
mettra tout en ligne, conduira à des temps de compilation plus longs, mais potentiellement plus rapides
temps d'exécution. Ce paramètre est ignoré pour les très petits modules ; ils seront toujours
inline, si autorisé.

-LDFLAGS drapeaux
Ajoutez les indicateurs d'éditeur de liens C spécifiés aux makefiles générés. Lorsque make est exécuté sur le
makefile généré ceux-ci seront passés à l'éditeur de liens C++ (ld) *après* le primaire
fichier étant lié. Ce drapeau s'appelle -LDFLAGS car c'est le nom traditionnel dans
simulateurs; il aurait mieux valu l'appeler LDLIBS car c'est la variable Makefile
il contrôle. (Dans Make, LDFLAGS est avant le premier objet, LDLIBS après. -L
les bibliothèques doivent être dans la variable Make LDLIBS, pas LDFLAGS.)

--Langue Plus-value
Un synonyme de "--default-langauge", pour la compatibilité avec d'autres outils et antérieurs
versions de Verilator.

+libext+poste+poste
Spécifiez les extensions qui doivent être utilisées pour rechercher des modules. Si par exemple module
x est référencé, regardez dans x.poste. Remarque +libext+ est assez standard dans Verilog
outils. Les valeurs par défaut sont .v et .sv.

--non pelucheux
Vérifiez les fichiers pour les violations de peluches uniquement, ne créez aucune autre sortie.

Vous pouvez également souhaiter que l'option -Wall active les messages considérés comme stylistiques
et non activé par défaut.

Si la conception ne doit pas être complètement vérifiée, consultez également --bbox-sys et
--options bbox-unsup.

--MMD
Activer la création de fichiers de dépendance .d, utilisés pour la détection de dépendance, similaire à
option gcc -MMD. Activé par défaut, utilisez --no-MMD pour désactiver.

--MP
Lors de la création de fichiers de dépendance .d avec --MMD, créez de fausses cibles. Similaire à gcc -MP
option.

--Mdir annuaire
Spécifie le nom du répertoire d'objet Make. Tous les fichiers générés seront placés
dans ce répertoire. S'il n'est pas spécifié, "obj_dir" est utilisé. Le répertoire est créé si
il n'existe pas et les répertoires parents existent ; sinon créer manuellement le Mdir
avant d'appeler Verilator.

--mod-préfixe topname
Spécifie le nom à ajouter à toutes les classes de niveau inférieur. La valeur par défaut est la même que
--préfixe.

--no-clk
Empêche le signal spécifié d'être marqué comme horloge. Voir "--clk".

--no-pins64
Alias ​​rétrocompatible pour "--pins-bv 33".

--no-saut-identique
Rarement nécessaire. Désactive l'omission de l'exécution de Verilator si tous les fichiers sources sont
identiques et tous les fichiers de sortie existent avec des dates plus récentes.

+notingchecks
Ignoré pour la compatibilité avec d'autres simulateurs.

-O0 Désactive l'optimisation du modèle.

-O3 Permet des optimisations lentes pour le code que Verilator lui-même génère (par opposition à
"-CFLAGS -O3" qui effectue l'optimisation du compilateur C. -O3 peut réduire la simulation
runtimes au détriment du temps de compilation. Cela définit actuellement --inline-mult -1.

-Olettre d'optimisation
Rarement nécessaire. Active ou désactive une optimisation spécifique, avec l'optimisation
sélectionné en fonction de la lettre transmise. Une lettre minuscule désactive une optimisation, une
la lettre majuscule le permet. Ceci est destiné uniquement au débogage ; voir la source
code pour les mappages dépendant de la version des optimisations aux lettres -O.

-o
Spécifiez le nom de l'exécutable final généré si vous utilisez --exe. Par défaut à la
--prefix si non spécifié.

--no-order-clock-retard
Rarement nécessaire. Désactive un correctif de bogue pour la commande de l'horloge active avec retardé
affectations. Ce drapeau ne doit être utilisé que lorsqu'il est suggéré par les développeurs.

--sortie-split octets
Permet de diviser les fichiers de sortie .cpp/.sp en plusieurs sorties. Lorsqu'un fichier C++
dépasse le nombre d'opérations spécifié, un nouveau fichier sera créé à la prochaine
limite de fonction. De plus, toutes les routines lentes seront placées dans des fichiers __Slow.
Cela accélère la compilation car l'optimisation peut être désactivée sur les routines lentes,
et les fichiers restants peuvent être compilés sur des machines parallèles. Utilisation de --output-split
ne devrait avoir qu'un impact négligeable sur les performances. Avec GCC 3.3 sur un Opteron 2GHz,
--output-split 20000 entraînera une division en une compilation d'environ une minute
morceaux.

--output-split-cfuncs déclarations
Permet de diviser les fonctions dans les fichiers de sortie .cpp/.sp en plusieurs fonctions.
Lorsqu'une fonction générée dépasse le nombre d'opérations spécifié, une nouvelle fonction
sera créé. Avec --output-split, cela permettra à GCC de compiler plus rapidement, à un
petite perte de performances qui s'aggrave avec la diminution des valeurs de fractionnement. Noter que
cette option est plus forte que --output-split dans le sens où --output-split ne
divisé à l'intérieur d'une fonction.

--output-split-ctrace déclarations
Permet de diviser les fonctions de trace dans les fichiers .cpp/.sp de sortie en plusieurs
les fonctions. Par défaut, le même paramètre que --output-split-cfuncs.

-P Avec -E, désactive la génération de marqueurs de ligne et de lignes vides, similaire à l'indicateur GCC -P.

--pins64
Alias ​​rétrocompatible pour "--pins-bv 65". Notez que c'est un 65, pas un 64.

--pins-bv largeur
Spécifie des entrées/sorties SystemC supérieures ou égales à largeur bits de large devraient
utilisez sc_bv au lieu de uint32/vluint64_t. La valeur par défaut est "--pins-bv 65". Versions
avant Verilator 3.671 défini par défaut sur "--pins-bv 33". Plus sc_bv est utilisé, pire
pour les performances. Utilisez l'attribut "/*verilator sc_bv*/" pour sélectionner des ports spécifiques à
être sc_bv.

--pins-sc-uint
Spécifie que les entrées/sorties SystemC d'une largeur supérieure à 2 bits doivent utiliser sc_uint
entre 2 et 64. Combiné avec la combinaison "--pins-sc-biguint", il en résulte
dans sc_uint étant utilisé entre 2 et 64 et sc_biguint étant utilisé entre 65 et 512.

--pins-sc-biguint
Spécifie que les entrées/sorties SystemC d'une largeur supérieure à 65 bits doivent utiliser sc_biguint
entre 65 et 512, et sc_bv à partir de 513. Lorsqu'il est combiné avec le
combinaison "--pins-sc-uint", il en résulte que sc_uint est utilisé entre 2 et 64 et
sc_biguint étant utilisé entre 65 et 512.

--pins-uint8
Spécifie les entrées/sorties SystemC qui sont plus petites que le paramètre --pins-bv et 8
bits ou moins doivent utiliser uint8_t au lieu de uint32_t. De même, les épingles de largeur 9-16
utilisez uint16_t au lieu de uint32_t.

--pipe-filtre commander
Rarement nécessaire et expérimental. Verilator générera la commande spécifiée en tant que
tube de sous-processus, pour permettre à la commande d'effectuer des modifications personnalisées sur le code Verilog
avant qu'il n'atteigne Verilator.

Avant de lire chaque fichier Verilog, Verilator transmettra le nom du fichier au sous-processus'
stdin avec 'read_verilog " "'. Le filtre peut alors lire le fichier et effectuer
tout filtrage qu'il souhaite, et renvoie le contenu du nouveau fichier à Verilator sur stdout
avec 'Contenu-Longueur'. La sortie vers stderr du filtre alimente le Verilator
stdout et si le filtre se termine avec un état différent de zéro, Verilator se termine. Voir le
test t/t_pipe_filter pour un exemple.

Pour déboguer la sortie du filtre, essayez d'utiliser l'option -E pour voir la sortie prétraitée.

--préfixe topname
Spécifie le nom de la classe de niveau supérieur et du makefile. La valeur par défaut est V précédé de
le nom du commutateur --top-module, ou V ajouté au premier nom de fichier Verilog
passé sur la ligne de commande.

--profile-cfuncs
Modifiez les fonctions C++ créées pour prendre en charge le profilage. Les fonctions seront
minimisé pour contenir une déclaration "de base", généralement un seul bloc ou fil toujours
déclaration. (Notez que cela ralentira l'exécutable de ~5%.) De plus, le
le nom de la fonction sera suffixé avec le nom de base du module Verilog et le numéro de ligne
la déclaration est venue. Cela permet de corréler les rapports gprof ou oprofile avec
les déclarations de source Verilog d'origine.

--privé
En face de --public. est la valeur par défaut ; cette option existe pour la compatibilité descendante.

--Publique
Ceci est uniquement pour une utilisation de débogage historique. Son utilisation peut entraîner une mauvaise simulation de
horloges générées.

Déclare tous les signaux et modules publics. Cela désactivera les optimisations de signal comme
si tous les signaux avaient un /*verilator public*/ commentaires et inline. Cela tournera aussi
off inlining comme si tous les modules avaient un /*verilator public_module*/, à moins que le module
spécifiquement activé avec /*verilator inline_module*/.

--report-unoptflat
Diagnostics supplémentaires pour les avertissements UNOPTFLAT. Cela inclut pour chaque boucle, les 10 plus larges
variables dans la boucle, et les 10 variables les plus déployées dans la boucle. Ceux-ci sont
candidats à la division en plusieurs variables pour rompre la boucle.

Produit en outre un fichier GraphViz DOT de l'ensemble des composants fortement connectés
dans la source associée à chaque boucle. Ceci est produit indépendamment du fait que
--dump-tree est défini. De tels graphiques peuvent aider à analyser le problème, mais peuvent être très
grand en effet.

Diverses commandes existent pour afficher et manipuler les fichiers DOT. Par exemple le point
La commande peut être utilisée pour convertir un fichier DOT en PDF pour l'impression. Par exemple:

point -Tpdf -O Vt_unoptflat_simple_2_35_unoptflat.dot

générera un PDF Vt_unoptflat_simple_2_35_unoptflat.dot.pdf à partir du fichier DOT.

--sauvable
Activez l'inclusion des fonctions de sauvegarde et de restauration dans le modèle généré.

Le code utilisateur doit créer un objet VerilatedSerialize ou VerilatedDeserialze puis
appeler les opérateurs << ou >> sur le modèle généré et toute autre donnée du processus
besoins sauvegardés/restaurés. Par exemple:

void save_model(const char* nomfichier) {
VerilatedSave os ;
os.open(nom_fichier);
os << main_time; // le code utilisateur doit enregistrer l'horodatage, etc.
os << *top;
}
void restaurer_model(const char* nomfichier) {
VerilatedRestore os ;
os.open(nom_fichier);
os >> main_time;
os >> *top;
}

--sc
Spécifie le mode de sortie SystemC ; voir aussi --cc.

--Statistiques
Crée un fichier de vidage avec des statistiques sur la conception dans {prefix}__stats.txt.

--stats-vars
Crée des statistiques plus détaillées, y compris une liste de toutes les variables par taille (plain
--stats donne juste un compte). Voir --stats, qui est impliqué par cela.

-sv Spécifie que les fonctionnalités du langage SystemVerilog doivent être activées ; équivalent à "--langue
1800-2005". Cette option est sélectionnée par défaut, elle existe pour la compatibilité avec
autres simulateurs.

+systèmeverilogext+poste
Un synonyme de "+1800-2012ext+"poste.

--top-module topname
Lorsque l'entrée Verilog contient plus d'un module de niveau supérieur, spécifie le nom de
le module Verilog de niveau supérieur pour devenir le premier et définit la valeur par défaut pour if --prefix
N'est pas utilisé. Ceci n'est pas nécessaire avec les conceptions standard avec un seul sommet.

--tracer
Ajoute un code de traçage de forme d'onde au modèle. Verilator générera des
Fichiers {prefix}__Trace*.cpp qui devront être compilés. en outre
verilated_vcd_sc.cpp (pour les traces SystemC) ou verilated_vcd_c.cpp (pour les deux) doit être
compilés et liés. Si vous utilisez les Makefiles générés par Verilator, ceux-ci seront
ajoutés comme cibles source pour vous. Si vous n'utilisez pas les makefiles de Verilator, vous
devrez les ajouter manuellement à votre Makefile.

La compilation du traçage peut entraîner de légères pertes de performances, même lorsque
les formes d'onde ne sont pas activées pendant l'exécution du modèle.

--trace-profondeur niveaux
Spécifiez le nombre de niveaux de profondeur pour activer le traçage, par exemple --trace-level 1 to
ne voient que les signaux de niveau supérieur. La valeur par défaut est l'ensemble du modèle. Utiliser un petit nombre
réduira la visibilité, mais améliorera considérablement le temps d'exécution et la taille du fichier de trace.

--trace-max-tableau profondeur
Rarement nécessaire. Spécifiez la profondeur maximale du réseau d'un signal pouvant être tracé.
La valeur par défaut est 32, car le traçage de grands tableaux peut considérablement ralentir les simulations tracées.

--trace-max-largeur largeur
Rarement nécessaire. Spécifiez la largeur de bit maximale d'un signal qui peut être tracé.
La valeur par défaut est 256, car le traçage de grands vecteurs peut considérablement ralentir les simulations tracées.

--no-trace-paramètres
Désactiver le traçage des paramètres.

--trace-structures
Activer le traçage pour afficher le nom des champs de structure compactée, d'union et de tableau compacté,
plutôt qu'un simple bus emballé combiné. En raison des contraintes de format de fichier VCD, cela peut
entraînent des temps de trace considérablement plus lents et des fichiers de trace plus volumineux.

--trace-trait de soulignement
Activez le traçage des signaux commençant par un trait de soulignement. Normalement, ces signaux sont
pas de sortie pendant le traçage. Voir aussi --coverage-underscore.

-Uvar
Dédéfinit le symbole de préprocesseur donné.

--unroll-count boucles
Rarement nécessaire. Spécifie le nombre maximal d'itérations de boucle pouvant être déroulées.
Voir aussi l'avertissement BLKLOOPINIT.

--unroll-stmts déclarations
Rarement nécessaire. Spécifie le nombre maximum d'instructions dans une boucle pour cette boucle à
être déroulé. Voir aussi l'avertissement BLKLOOPINIT.

--expression régulière-inutilisée regexp
Rarement nécessaire. Spécifie une expression rationnelle simple avec * et ? que si un nom de signal correspond
supprimera l'avertissement UNUSED. La valeur par défaut est "*unused*". Le définir sur "" désactive
correspondant à.

-V Affiche la version détaillée, y compris les informations de configuration compilées dans
Vérificateur. (Similaire à perl -V.)

-v nom de fichier
Lisez le nom de fichier en tant que bibliothèque Verilog. Tous les modules du fichier peuvent être utilisés pour
résoudre les instanciations de cellule dans le module de niveau supérieur, sinon ignoré. Remarque -v est assez
standard dans tous les outils Verilog.

+verilog1995ext+poste
+verilog2001ext+poste
Synonymes pour "+1364-1995ext+"poste et "+1364-2001ext+"poste respectivement

-Mur
Activer tous les avertissements, y compris les avertissements de style de code qui sont normalement désactivés par
défaut.

-Werreur-message
Convertit le message d'avertissement spécifié en message d'erreur. Il s'agit généralement de
décourager les utilisateurs de violer des règles importantes à l'échelle du site, par exemple
"-Werror-NOUNOPTFLAT".

-Wavenir-message
Rarement nécessaire. Supprimer les commentaires ou messages d'avertissement inconnus de Verilator avec le
code-messages. Ceci est utilisé pour autoriser le code écrit avec des pragmas pour une version ultérieure de
Verilator pour fonctionner sous une ancienne version ; ajouter des arguments -Wfuture- pour chaque code de message
ou commentez que la nouvelle version prend en charge ce que l'ancienne version ne prend pas en charge.

-Wnon-message
Désactive le message d'avertissement spécifié. Cela remplacera toutes les directives lint_on dans
la source, c'est-à-dire que l'avertissement ne sera toujours pas imprimé.

-Pas de peluches
Désactivez tous les messages d'avertissement liés aux peluches et tous les avertissements de style. C'est équivalent
à "-Wno-ALWCOMBORDER -Wno-CASEINCOMPLETE -Wno-CASEOVERLAP -Wno-CASEX -Wno-CASEWITHX
-Wno-CMPCONST -Wno-ENDLABEL -Wno-IMPLICIT -Wno-LITENDIAN -Wno-PINCONNECTEMPTY
-Wno-PINMISSING -Wno-SYNCASYNCNET -Wno-UNDRIVEN -Wno-UNSIGNED -Wno-UNUSED -Wno-WIDTH"
plus la liste affichée pour le style Wno.

Il est fortement recommandé de nettoyer votre code plutôt que d'utiliser cette option, il est
uniquement destiné à être utilisé lors de l'exécution de cas de test de code reçu de tiers.

-Style Wno
Désactivez tous les messages d'avertissement liés au style de code (notez par défaut qu'ils sont déjà
désactivée). Ceci est équivalent à "-Wno-DECLFILENAME -Wno-DEFPARAM -Wno-INCABSPATH
-Wnon-PINCONNECTEMPTY -Wnon-PINNOCONNECT -Wnon-SYNCASYNCNET -Wnon-UNDRIVEN -Wnon-UNUSED
-Wno-VARHIDDEN".

-Wnon-fatal
Lorsque des avertissements sont détectés, imprimez-les, mais ne quittez pas le simulateur.

Avoir des messages d'avertissement dans les builds est bâclé. Il est fortement recommandé de nettoyer
votre code, utilisez lint_off en ligne ou utilisez les indicateurs -Wno-... plutôt que d'utiliser cette option.

-Avertissez-message
Active le message d'avertissement spécifié.

-Wwarn-peluche
Activer tous les messages d'avertissement liés aux peluches (notez par défaut qu'ils sont déjà activés),
mais n'affecte pas les messages de style. Ceci est équivalent à "-Wwarn-ALWCOMBORDER
-Wwarn-CASEINCOMPLETE -Wwarn-CASEOVERLAP -Wwarn-CASEX -Wwarn-CASEWITHX -Wwarn-CMPCONST
-Wwarn-ENDLABEL -Wwarn-IMPLICIT -Wwarn-LITENDIAN -Wwarn-PINMISSING -Wwarn-REALCVT
-Wwarn-UNSIGNED -Wwarn-WIDTH".

-Style Wwarn
Activez tous les messages d'avertissement liés au style de code. Ceci est équivalent à "-Wwarn
ASSIGNDLY -Wwarn-DECLFILENAME -Wwarn-DEFPARAM -Wwarn-INCABSPATH -Wwarn-PINNOCONNECT
-Wwarn-SYNCASYNCNET -Wwarn-UNDRIVEN -Wwarn-UNUSED -Wwarn-VARHIDDEN".

--x-assigner 0
--x-assigner 1
--x-assign rapide (par défaut)
--x-assignation unique
Contrôle la valeur à deux états qui est remplacée lorsqu'une affectation à X est rencontrée.
--x-assign=fast, la valeur par défaut, convertit tous les X en ce qui est le mieux pour les performances.
--x-assign=0 convertit tous les X en 0 et est également rapide. --x-assign=1 convertit tous les X en
1s, c'est presque aussi rapide que 0, mais plus susceptible de trouver des bogues de réinitialisation comme actif élevé
la logique se déclenchera. --x-assign=unique appellera une fonction pour déterminer la valeur, cette
permet la randomisation de tous les X pour trouver les bogues de réinitialisation et est le plus lent, mais le plus sûr pour
trouver des bogues de réinitialisation dans le code.

Si vous utilisez --x-assign unique, vous voudrez peut-être semer votre générateur de nombres aléatoires tel
que chaque exécution de régression obtient une séquence de randomisation différente. Utilisez le système
srand48() ou pour Windows srand() fonction pour le faire. Vous voudrez probablement aussi
imprimez toutes les graines sélectionnées et codez pour permettre la réexécution avec cette même graine afin que vous puissiez
reproduire des bogues.

Note. Cette option s'applique uniquement aux variables qui sont explicitement affectées à X dans le
Code source Verilog. Les valeurs initiales des horloges sont définies sur 0 sauf si --x-initial-edge est
spécifié. Les valeurs initiales de toutes les autres variables de maintien d'état sont définies comme si
--x-assign unique avait été spécifié.

--x-bord-initial
Permet l'émulation de simulateurs pilotés par événements qui déclenchent généralement un front sur un
passage de X à 1 ("posedge") ou de X à 0 ("negedge"). Ainsi le code suivant,
où "rst_n" n'est pas initialisé mettrait "res_n" à "1'b1" lorsque "rst_n" est défini pour la première fois
à zéro :

reg res_n = 1'b0;

toujours @(negedge rst_n) commencer
si (rst_n == 1'b0) commencer
res_n <= 1'b1;
fin
fin

Dans Verilator, par défaut, les horloges non initialisées reçoivent une valeur de zéro, donc ce qui précède
Le bloc "toujours" ne se déclencherait pas.

Bien que ce ne soit pas une bonne pratique, certaines conceptions reposent sur XX 0 déclenchant un
"negedge", en particulier dans les séquences de réinitialisation. L'utilisation de --x-initial-edge avec Verilator
reproduire ce comportement. Il s'assurera également que XX 1 déclenche un "posege".

Note. Certains utilisateurs ont signalé que l'utilisation de cette option peut affecter la convergence, et que
il peut être nécessaire d'utiliser --converge-limit pour augmenter le nombre de convergence
itérations. Cela peut être une autre indication de problèmes avec la conception modélisée qui
doivent être adressées.

-y dir
Ajouter le répertoire à la liste des répertoires qui doivent être recherchés pour les fichiers d'inclusion
ou des bibliothèques. Les trois indicateurs -y, +incdir et -I ont un effet similaire ; +incdir et +y
sont assez standard pour les outils Verilog tandis que -I est un alias pour la compatibilité GCC.

Verilator utilise par défaut le répertoire actuel ("-y .") et tout --Mdir spécifié, cependant
ces chemins par défaut sont utilisés après tous les répertoires spécifiés par l'utilisateur. Cela permet '-y
"$(pwd)"' à utiliser si des noms de fichiers absolus sont souhaités pour les messages d'erreur au lieu de
noms de fichiers relatifs.

EXEMPLE C + + EXÉCUTION

Nous allons compiler cet exemple en C++.

mkdir test_our
cd test_notre

chat < notre.v
moduler notre;
initial begin $display("Hello World"); $finir ; finir
module de fin
EOF

chat < sim_main.cpp
#include "Vour.h"
#include "vérifié.h"
int main(int argc, char **argv, char **env) {
Vérifié::commandArgs(argc, argv);
Vour* haut = nouveau Vour;
while (!Verilated::gotFinish()) { top->eval(); }
supprimer le haut ;
sortie(0);
}
EOF

Si vous avez installé Verilator à partir de sources ou d'une archive tar, mais pas dans le cadre de votre
système (en tant que RPM), vous devez d'abord pointer vers le kit :

export VERILATOR_ROOT=/chemin/vers/où/vérificateur/était/installé
export PATH=$VERILATOR_ROOT/bin:$PATH

Maintenant, exécutons Verilator sur notre petit exemple.

verilator -Wall --cc our.v --exe sim_main.cpp

Nous pouvons voir le code source sous le répertoire "obj_dir". Voir la section FICHIERS ci-dessous pour
descriptions de certains des fichiers qui ont été créés.

ls -l rép_obj

On peut alors le compiler

cd obj_dir
make -j -f Vour.mk Vour

(Verilator a inclus une règle de compilation par défaut et une règle de lien, puisque nous avons utilisé --exe et transmis un
.cpp sur la ligne de commande Verilator. Vous pouvez également écrire vos propres règles de compilation, comme
nous allons montrer dans la section SYSTEMC.)

Et maintenant nous l'exécutons

cd ..
obj_dir/Votre

Et nous obtenons en sortie

Bonjour tout le monde
- our.v:2 : Verilog $finish

Vraiment, vous feriez mieux d'écrire un Makefile pour faire tout cela pour vous. Ensuite, lorsque votre
modifications de la source, il exécutera automatiquement toutes ces étapes. Voir le répertoire test_c dans
la distribution pour un exemple.

EXEMPLE SYSTÈME EXÉCUTION

Il s'agit d'un exemple similaire à celui ci-dessus, mais utilisant SystemC.

mkdir test_our_sc
cd test_our_sc

chat < notre.v
module notre (clk);
clé d'entrée ; // L'horloge est requise pour obtenir l'activation initiale
toujours @ (posedge clk)
begin $ display("Hello World"); $finir ; finir
module de fin
EOF

chat < sc_main.cpp
#include "Vour.h"
int sc_main(int argc, char **argv) {
Vérifié::commandArgs(argc, argv);
sc_clock clk ("clk",10, 0.5, 3, true);
Vour* haut;
top = new Vour("top"); // SP_CELL (haut, Vour);
haut->clk(clk); // SP_PIN (top, clk, clk);
while (!Verilated::gotFinish()) { sc_start(1, SC_NS); }
supprimer le haut ;
sortie(0);
}
EOF

Si vous avez installé Verilator à partir de sources ou d'une archive tar, mais pas dans le cadre de votre
système (en tant que RPM), vous devez d'abord pointer vers le kit :

export VERILATOR_ROOT=/chemin/vers/où/vérificateur/était/installé
export PATH=$VERILATOR_ROOT/bin:$PATH

Maintenant, exécutons Verilator sur notre petit exemple.

verilator -Mur --sc our.v

On peut alors le compiler

make -j -f Vour.mk Vour__ALL.a
make -j -f Vour.mk ../sc_main.o verilated.o

Et lien avec SystemC. Notez que votre chemin vers les bibliothèques peut varier, selon le
système opérateur.

export SYSTEMC_LIBDIR=/chemin/vers/où/libsystemc.a/exists
exporter LD_LIBRARY_PATH=$SYSTEMC_LIBDIR:$LD_LIBRARY_PATH
# Peut être nécessaire si SystemC 2.3.0
exporter SYSTEMC_CXX_FLAGS=-pthread

g++ -L$SYSTEMC_LIBDIR ../sc_main.o Vour__ALL*.o verilated.o
-o Votre -lsystemc

Et maintenant nous l'exécutons

cd ..
obj_dir/Votre

Et nous obtenons le même résultat que l'exemple C++ :

Bonjour tout le monde
- our.v:2 : Verilog $finish

Vraiment, vous feriez mieux d'utiliser un Makefile pour faire tout cela pour vous. Ensuite, lorsque votre source
change, il exécutera automatiquement toutes ces étapes. Voir le répertoire test_sc dans le
distribution pour un exemple.

ANALYSE DE RÉFÉRENCE & OPTIMISATION

Pour de meilleures performances, exécutez Verilator avec les indicateurs "-O3 --x-assign=fast --noassert". Les
L'indicateur -O3 nécessitera des temps de compilation plus longs et --x-assign=fast peut augmenter le risque de
réinitialiser les bogues dans le commerce pour les performances ; voir la documentation ci-dessus pour ces drapeaux.

Des modifications mineures du code Verilog peuvent également donner de gros gains. Vous ne devriez pas avoir d'UNOPTFLAT
avertissements de Verilator. La correction de ces avertissements peut entraîner d'énormes améliorations ; un utilisateur
a corrigé leur avertissement UNOPTFLAT en apportant une simple modification à un verrou d'horloge utilisé pour la porte
horloges et a gagné une amélioration des performances de 60%.

Au-delà de cela, les performances d'un modèle vérifié dépendent principalement de votre compilateur C++ et
taille des caches de votre CPU.

Par défaut, l'optimisation du fichier lib/verilated.mk est désactivée. C'est pour le
profit des nouveaux utilisateurs, car il améliore les temps de compilation au détriment des temps d'exécution. Ajouter
optimisation par défaut, définissez l'une des trois variables, OPT, OPT_FAST ou OPT_SLOW
lib/verilated.mk. Ou, utilisez l'option -CFLAGS et/ou -LDFLAGS sur la commande verilator
pour passer les drapeaux directement au compilateur ou à l'éditeur de liens. Ou, juste pour une course, passe
les sur la ligne de commande pour faire :

make OPT_FAST="-O2" -f Vour.mk Vour__ALL.a

OPT_FAST spécifie les optimisations pour les programmes qui font partie du chemin rapide, principalement
code qui est exécuté à chaque cycle. OPT_SLOW spécifie les optimisations pour les fichiers à chemin lent
(plus le traçage), qui ne s'exécutent que rarement, mais prennent beaucoup de temps à compiler avec
optimisation activée. OPT spécifie l'optimisation globale et affecte toutes les compilations, y compris
ces OPT_FAST et OPT_SLOW affectent. Pour de meilleurs résultats, utilisez OPT="-O2", et créez un lien avec
"-statique". Presque les mêmes résultats peuvent être obtenus avec des temps de compilation bien meilleurs avec
OPT_FAST="-O1 -fstrict-aliasing". Une optimisation plus élevée telle que "-O3" peut aider, mais gcc
les temps de compilation peuvent être excessifs sous O3 même sur des conceptions de taille moyenne. Alternativement, certains
les conceptions plus grandes rapportent de meilleures performances en utilisant "-Os".

Malheureusement, l'utilisation de l'optimiseur avec des fichiers SystemC peut entraîner des compilations prenant
plusieurs minutes. (Les bibliothèques SystemC ont de nombreuses petites fonctions intégrées qui pilotent le
écrous du compilateur.)

Pour de meilleurs résultats, utilisez GCC 3.3 ou une version plus récente. GCC 3.2 et versions antérieures ont des bugs d'optimisation autour
détection d'alias de pointeur, ce qui peut entraîner des pertes de performances 2x.

Si vous allez exécuter de nombreuses simulations sur une seule compilation, étudiez les commentaires
compilation. Avec GCC, en utilisant -fprofile-arcs, alors -fbranch-probabilities donnera
encore 15 % environ.

Les compilateurs modernes prennent également en charge l'optimisation du temps de liaison (LTO), ce qui peut aider surtout si
vous liez dans le code DPI. Pour activer LTO sur GCC, passez "-flto" à la fois dans la compilation et dans le lien.
Remarque LTO peut entraîner des temps de compilation excessifs sur des conceptions volumineuses.

Si vous utilisez vos propres makefiles, vous voudrez peut-être compiler le code vérifié avec
-DVL_INLINE_OPT=en ligne. Cela inline les fonctions, mais cela nécessite que tous les cpp
les fichiers soient compilés en une seule exécution du compilateur.

Vous pouvez découvrir d'autres possibilités de réglage en profilant le code Verilog. Utilisation
--profile-cfuncs de Verilator, puis -g -pg de GCC. Vous pouvez ensuite exécuter oprofile ou
gprof pour voir où dans le code C++ le temps est passé. Exécutez la sortie gprof via
verilator_profcfunc et il vous dira quels numéros de ligne Verilog sur lesquels la plupart des
le temps est dépensé.

Une fois terminé, veuillez informer l'auteur des résultats. J'aime garder un œil sur la façon dont Verilator
compare et peut être en mesure de suggérer des améliorations supplémentaires.

Utilisez verilator_bin_dbg en ligne à l'aide des services onworks.net