Qu'est-ce que le fichier cmd sous Linux

Sous Linux, le fichier cmd est le fichier de commande de lien, qui stocke les informations de configuration de l'éditeur de liens et peut être appelé fichier de commande ; la fonction du fichier cmd est d'indiquer comment lier le programme. Le fichier cmd se compose de deux parties : MEMORY et SECTIONS : MEMORY est utilisé pour définir le nom, l'adresse de début et la longueur de chaque bloc de mémoire. SECTIONS est principalement utilisé pour décrire quel segment est mappé à quel segment de l'espace de stockage.

L'environnement d'exploitation de ce tutoriel : système linux7.3, ordinateur Dell G3.

Qu'est-ce qu'un fichier cmd ?

Les fichiers cmd sont des fichiers de commandes de l'éditeur de liens (Linker Command Files), se terminant par le suffixe .cmd.

Le nom professionnel de CMD est fichier de configuration de l'éditeur de liens, qui stocke les informations de configuration de l'éditeur de liens. Nous l'appelons en abrégé fichier de commande. Comme son nom l'indique, le but de ce fichier est de spécifier comment lier le programme.

Ensuite, nous savons que lors de l'écriture d'un programme TI DSP, le programme peut être divisé en de nombreux segments, tels que texte, bss, etc., et chaque segment a un rôle différent. Lors du tournage du film, le lieu est également différent. Par exemple, le code texte doit généralement être placé en flash, tandis que les variables bss doivent être placées en RAM. etc. Cependant, pour différentes puces, les adresses de début et de fin de chaque mémoire sont différentes. De plus, l'éditeur de liens ne sait pas où dans quelle mémoire l'utilisateur souhaite placer une certaine section, notamment une section personnalisée. Afin d'indiquer à l'éditeur de liens l'allocation de l'espace de stockage interne de la puce à utiliser et l'emplacement de stockage spécifique de chaque section du programme, il est nécessaire d'écrire un fichier de configuration, c'est-à-dire un fichier CMD.

Le fichier cmd se compose de deux parties : MEMORY (c'est-à-dire : mémoire) et SECTIONS (c'est-à-dire : segments). MEMERY est utilisé pour définir le nom, l'adresse de départ et la longueur de chaque bloc mémoire. SECTIONS est principalement utilisé pour décrire quel segment est mappé à quel segment de l'espace de stockage. La MÉMOIRE peut être divisée en PAGE0 (espace de stockage du programme) et PAGE1 (espace de stockage de données), PAGE (c'est-à-dire : cadre).

Les segments mentionnés ci-dessus peuvent être divisés en deux catégories : les segments initialisés et les segments non initialisés. Le segment initialisé contient les instructions et les données réelles et est stocké dans l'espace mémoire du programme. Le segment non initialisé réserve uniquement l'espace d'adressage de la variable. Le segment non initialisé n'a pas de contenu réel. Les données sont écrites dans la variable pendant l'exécution du programme et stockées dans l'espace de stockage de données. En langage C, il existe de nombreux segments définis, tels que « .text », « .const » et « .system ». Pour ces segments définis, il existe de nombreuses explications à leur sujet sur Internet, je n'entrerai donc pas dans les détails ici. Cet article présentera ensuite aux lecteurs comment définir eux-mêmes des segments en tant qu'utilisateur.

MEMOIRE et SECTION

Les commentaires peuvent être écrits dans le fichier cmd, entourés de "/*" et "*/", mais "//" n'est pas autorisé, ce qui est différent du langage c.

Pour écrire des fichiers cmd, nous devons utiliser deux pseudo-instructions MEMORY et SECTIONS (doivent être en majuscules).

La syntaxe de MEMORY et SECTION peut être trouvée en ligne. Cet article expliquera le contenu de MEMORY et SECTION avec des exemples spécifiques.

Expliquez MEMORY en vous basant sur le fichier cmd de F28335 utilisé par l'auteur.

MEMORY
{
PAGE 0:    /* Program Memory */
           /* Memory (RAM/FLASH/OTP) blocks can be moved to PAGE1 for data allocation */
 
   ZONE0       : origin = 0x004000, length = 0x001000     /* XINTF zone 0 */
   RAML0       : origin = 0x008000, length = 0x001000     /* on-chip RAM block L0 */
   RAML1       : origin = 0x009000, length = 0x001000     /* on-chip RAM block L1 */
   RAML2       : origin = 0x00A000, length = 0x001000     /* on-chip RAM block L2 */
   RAML3       : origin = 0x00B000, length = 0x001000     /* on-chip RAM block L3 */
   ZONE6       : origin = 0x0100000, length = 0x100000    /* XINTF zone 6 */ 
   ZONE7A      : origin = 0x0200000, length = 0x00FC00    /* XINTF zone 7 - program space */ 
   FLASHH      : origin = 0x300000, length = 0x008000     /* on-chip FLASH */
   FLASHG      : origin = 0x308000, length = 0x008000     /* on-chip FLASH */
   FLASHF      : origin = 0x310000, length = 0x008000     /* on-chip FLASH */
   FLASHE      : origin = 0x318000, length = 0x008000     /* on-chip FLASH */
   FLASHD      : origin = 0x320000, length = 0x008000     /* on-chip FLASH */
   FLASHC      : origin = 0x328000, length = 0x008000     /* on-chip FLASH */
   FLASHA      : origin = 0x338000, length = 0x007F80     /* on-chip FLASH */
   CSM_RSVD    : origin = 0x33FF80, length = 0x000076     /* Part of FLASHA.  Program with all 0x0000 when CSM is in use. */
   BEGIN       : origin = 0x33FFF6, length = 0x000002     /* Part of FLASHA.  Used for "boot to Flash" bootloader mode. */
   CSM_PWL     : origin = 0x33FFF8, length = 0x000008     /* Part of FLASHA.  CSM password locations in FLASHA */
   OTP         : origin = 0x380400, length = 0x000400     /* on-chip OTP */
   ADC_CAL     : origin = 0x380080, length = 0x000009     /* ADC_cal function in Reserved memory */
   
   IQTABLES    : origin = 0x3FE000, length = 0x000b50     /* IQ Math Tables in Boot ROM */
   IQTABLES2   : origin = 0x3FEB50, length = 0x00008c     /* IQ Math Tables in Boot ROM */  
   FPUTABLES   : origin = 0x3FEBDC, length = 0x0006A0     /* FPU Tables in Boot ROM */
   ROM         : origin = 0x3FF27C, length = 0x000D44     /* Boot ROM */        
   RESET       : origin = 0x3FFFC0, length = 0x000002     /* part of boot ROM  */
   VECTORS     : origin = 0x3FFFC2, length = 0x00003E     /* part of boot ROM  */
 
PAGE 1 :   /* Data Memory */
           /* Memory (RAM/FLASH/OTP) blocks can be moved to PAGE0 for program allocation */
           /* Registers remain on PAGE1                                                  */
   
   BOOT_RSVD   : origin = 0x000000, length = 0x000050     /* Part of M0, BOOT rom will use this for stack */
   RAMM0       : origin = 0x000050, length = 0x0003B0     /* on-chip RAM block M0 */
   RAMM1       : origin = 0x000400, length = 0x000400     /* on-chip RAM block M1 */
   RAML4       : origin = 0x00C000, length = 0x001000     /* on-chip RAM block L1 */
   RAML5       : origin = 0x00D000, length = 0x001000     /* on-chip RAM block L1 */
   RAML6       : origin = 0x00E000, length = 0x001000     /* on-chip RAM block L1 */
   RAML7       : origin = 0x00F000, length = 0x001000     /* on-chip RAM block L1 */
   ZONE7B      : origin = 0x20FC00, length = 0x000400     /* XINTF zone 7 - data space */
   FLASHB      : origin = 0x330000, length = 0x008000     /* on-chip FLASH */
}

Vous pouvez voir que MEMORY contient généralement PAGE0 et PAGE1 dans PAGE0 représente l'espace de stockage avec une adresse de départ de 0x008000 et une longueur d'espace de stockage de 0x001000. De la même manière, nous pouvons connaître la signification d’autres noms d’espaces de stockage.

En comparant le manuel des données de la puce TI28335 (seule une partie est interceptée), nous pouvons voir que l'écriture du fichier cmd ci-dessus est basée sur la section de mappage mémoire du manuel des données de la puce TI28335. Nous pouvons également nous référer à la section de mappage de la mémoire dans le manuel des données de la puce pour écrire le fichier cmd.

Ensuite, l'auteur expliquera le contenu contenu dans SECTION. En prenant le fichier cmd de F28335 comme exemple

SECTIONS
{
 
   /* Allocate program areas: */
   .cinit              : > FLASHA      PAGE = 0
   .pinit              : > FLASHA,     PAGE = 0
   .text               : > FLASHA      PAGE = 0
   codestart           : > BEGIN       PAGE = 0
   ramfuncs            : LOAD = FLASHD, 
                         RUN = RAML0, 
                         LOAD_START(_RamfuncsLoadStart),
                         LOAD_END(_RamfuncsLoadEnd),
                         RUN_START(_RamfuncsRunStart),
                         LOAD_SIZE(_RamfuncsLoadSize),
                         PAGE = 0
 
   csmpasswds          : > CSM_PWL     PAGE = 0
   csm_rsvd            : > CSM_RSVD    PAGE = 0
   
   /* Allocate uninitalized data sections: */
   .stack              : > RAMM1       PAGE = 1
   .ebss               : > RAML4       PAGE = 1
   .esysmem            : > RAMM1       PAGE = 1
 
   /* Initalized sections go in Flash */
   /* For SDFlash to program these, they must be allocated to page 0 */
   .econst             : > FLASHA      PAGE = 0
   .switch             : > FLASHA      PAGE = 0      
 
   /* Allocate IQ math areas: */
   IQmath              : > FLASHC      PAGE = 0                  /* Math Code */
   IQmathTables     : > IQTABLES,  PAGE = 0, TYPE = NOLOAD 
   
   /* Uncomment the section below if calling the IQNexp() or IQexp()
      functions from the IQMath.lib library in order to utilize the 
      relevant IQ Math table in Boot ROM (This saves space and Boot ROM 
      is 1 wait-state). If this section is not uncommented, IQmathTables2
      will be loaded into other memory (SARAM, Flash, etc.) and will take
      up space, but 0 wait-state is possible.
   */
   /*
   IQmathTables2    : > IQTABLES2, PAGE = 0, TYPE = NOLOAD 
   {
   
              IQmath.lib<IQNexpTable.obj> (IQmathTablesRam)
   
   }
   */
   
   FPUmathTables    : > FPUTABLES, PAGE = 0, TYPE = NOLOAD 
         
   /* Allocate DMA-accessible RAM sections: */
   DMARAML4         : > RAML4,     PAGE = 1
   DMARAML5         : > RAML5,     PAGE = 1
   DMARAML6         : > RAML6,     PAGE = 1
   DMARAML7         : > RAML7,     PAGE = 1
   
   /* Allocate 0x400 of XINTF Zone 7 to storing data */
   ZONE7DATA        : > ZONE7B,    PAGE = 1
 
   /* .reset is a standard section used by the compiler.  It contains the */ 
   /* the address of the start of _c_int00 for C Code.   /*
   /* When using the boot ROM this section and the CPU vector */
   /* table is not needed.  Thus the default type is set here to  */
   /* DSECT  */ 
   .reset              : > RESET,      PAGE = 0, TYPE = DSECT
   vectors             : > VECTORS     PAGE = 0, TYPE = DSECT
   
   /* Allocate ADC_cal function (pre-programmed by factory into TI reserved memory) */
   .adc_cal     : load = ADC_CAL,   PAGE = 0, TYPE = NOLOAD
 
}

, vous pouvez voir que SECTION contient différents noms de section. Prenons ".text" comme exemple. ".text" est le segment de code d'instruction binaire généré après la compilation. Vous pouvez voir que nous allouons le contenu de ".text" à FLASHA pour le stockage, et FLASHA se trouve à la PAGE0 dans MEMORY.

Les fonctions de la SECTION sont liées au démarrage de 28335. Son essence est de lire le code utilisateur de FLASH via le "programme d'amorçage" lors de la mise sous tension et de l'exécution, de l'enregistrer dans la RAM et de l'exécuter dans la RAM, résolvant ainsi le problème. problème de vitesse lente de lecture et d'écriture de la ROM, il est difficile de résoudre le problème des puces intelligentes à grande vitesse et de la perte de données de la RAM en raison d'une panne de courant.

Segment personnalisé

Et à quoi sert la connaissance de ces informations sur le segment pour nos utilisateurs ? L'utilisation la plus directe est que lorsque le compilateur indique que la mémoire est insuffisante, nous pouvons trouver l'espace de stockage correspondant via le nom du segment correspondant et modifier la taille de son espace de stockage pour répondre aux besoins de notre programme. Nous pouvons même stocker notre code et nos données en personnalisant les noms de segments.

Passez #pragma DATA_SECTION (nom de fonction ou nom de variable globale, "nom de segment défini par l'utilisateur dans l'espace de données") ou #pragma CODE_SECTION (nom de fonction ou nom de variable globale, "nom de segment défini par l'utilisateur dans l'espace de programme") Segment personnalisé des noms peuvent être implémentés pour allouer librement de l’espace de stockage.

#pragma DATA_SECTION (pour les variables)

#pragma CODE_SECTION（用于函数）

但使用以上指令时需注意：不能在函数体内声明必须在定义和使用前声明，#pragma可以阻止对未调用的函数的优化。

下面结合实际使用例子来具体讲解：

#pragma DATA_SECTION(FFT_output, "FFT_buffer1");
float FFT_output[FFT_SIZE];

笔者声明了一个数据段，段名为FFT_buffer1，段的内容在变量FFT_ouput里。而声明后才定义变量FFT_output的大小。

我们如果想要使用这个自定义的段，接下来我们还要在CMD文件的SECTION中指定FFT_buffer1的存储空间。

FFT_buffer1		: > RAML4,     PAGE = 1

通过以上几条语句，笔者实现了将变量的内容存放入指定的RAML4存储空间的操作。

从上可以得出，当全局变量所占内存过大时，我们可以通过自定义段选择有所余裕的存储空间的方式，从而来解决内存不足的问题。

相关推荐：《Linux视频教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!