Comment utiliser C définit dans les BRAS de l'assembleur

Comment puis-je utiliser externe définit comme LONG_MIN et LONG_MAX dans les BRAS du code assembleur?

Disons my_arm.h ressemble à ceci:

int my_arm(int foo);

Disons que j'ai un my_main.c comme suit:

...
#include <limits.h>   
#include "my_arm.h"
...
int main (int argc, char *argv[])
{
  int foo=0;
...
  printf("My arm assembler function returns (%d)\n", my_arm(foo));
...
}

Et my_arm.s ressemble à ceci:

  .text
  .align 2
  .global my_arm
  .type   my_arm, %function
my_arm:
    ...
    ADDS r1, r1, r2
    BVS overflow
    ...
overflow: 
    LDR r0, LONG_MAX @ this is probably wrong, how to do it correctly?
    BX lr @ return with max value

La seconde à la dernière ligne, je ne suis pas sûr de savoir comment charger correctement, je me souviens vaguement avoir lu quelque part, que je devais définir LONG_MAX .au niveau mondial, mais ne peut pas trouver le lien pour un exemple plus.

Je compile avec arm-linux-gnueabi-gcc version 4.3.2

==================

Mise à JOUR: Apprécier les suggestions! Malheureusement, je suis toujours avoir des problèmes avec la syntaxe.

Tout d'abord, j'ai fait un petit fichier d'en-tête mylimits.h (pour l'instant en même dir .S)

#define MY_LONG_MIN 0x80000000

dans my_arm.S j'ai ajouté ce qui suit:

...
.include "mylimits.h"
...
ldr r7, =MY_LONG_MIN @ when it was working it was ldr r7, =0x80000000
...

Deux problèmes avec cette approche.

D'abord le plus gros problème: le symbole MY_LONG_MIN n'est pas reconnu...donc, quelque chose est pas encore le droit

Deuxième: de la syntaxe .inclure ne me laisse pas inclure <limits.h>, je dois ajouter que dans mylimits.h, semble un peu encombrants, mais je suppose que c'est ok 🙂

Les pointeurs?

J'ai accès à Système de BRAS Guide du Développeur de la Conception et de l'Optimisation de Système Logiciel[2004] et de l'Architecture ARM
Manuel de référence[2000], mon objectif est XScale-IXP42x Famille rev 2 (v5l).

Ne sais pas sur les BRAS, mais si vous en mips, en renommant l'extension du .S fait C prétraiter le fichier.
utiliser #include pas .comprendre, et .S pas .s, comme il est dit dans la réponse. De cette façon, vous exploiter un gcc fonctionnalité, et tout devrait aller comme pour mes tests en x86, en dehors de l'assemblée qui est évidemment différent

OriginalL'auteur Sint | 2010-06-19

11

Souvent minuscules extension de fichier .s implique que l'assembleur ne doit pas être passé par le préprocesseur c, alors que les majuscules extension .S implique qu'elle devrait.
C'est à votre compilateur pour suivre cette convention (gcc ports normalement), afin de vérifier sa documentation.

(EDIT: notez que cela signifie que vous pouvez utiliser la directive #include - mais n'oubliez pas que la plupart des fichiers vous ne serait pas normalement être valide assembleur (sauf s'ils sont entièrement constitués de #defineitions), donc vous pouvez écrire votre propre en-tête)

edit 5 ans plus tard:

Noter que l'armcc v5 compilateur suit ce comportement sous linux... mais pas sur windows.

Si la chaîne de compilation GCC est utilisé, le __ASSEMBLER__ macro est définie lors de prétraitement des fichiers d'assemblage. Qui peut être utilisé pour aider à un .h fichier de travail dans le monde (asm et C) si nécessaire. Mais ça peut être préférable de séparer les éléments qui doivent travailler dans les deux mondes, dans un en-tête différent, si possible. Si pour quelque chose comme LONG_MAX qui est définie dans un en-tête standard, vous n'avez pas beaucoup de contrôle sur...
Oui, il n'est pas beaucoup d'utilisation avec des en-têtes standard! (Sauf parfois pour l'architecture, les en-têtes de définir les choses comme mappés en mémoire IO adresses, qui sont conçus pour le but)

OriginalL'auteur James
2

Si vous utilisez gcc et son assembleur, c'est simple: indiquez le nom du fichier à final .S, puis ajouter au début de l' #include <limits.h> et l'utiliser partout où vous avez besoin de la constante, par exemple ldr r0, SOMETHING; j'ai fait des tests avec x86 puisque c'est ce que j'ai, mais les mêmes œuvres, car il est un gcc fonctionnalité.

OriginalL'auteur ShinTakezou
1

Ce que j'ai fini par faire, c'est ceci:

dans my_main.c
```
#include <limits.h>
...
int my_LONG_MAX=LONG_MAX;
```
puis dans my_arm.S
```
ldr r8, =my_LONG_MAX 
ldr r10, [r8] 
```
Il semble convuluted et c'est(en plus de la portabilité des gains sont discutables dans cette approche).

Il doit y avoir un moyen d'accéder à LONG_MAX directement dans l'assemblée. Une telle façon que je serais heureux de les accepter comme une réponse complète.

si quelqu'un veut ajouter une meilleure solution, je serai heureux d'accepter cette réponse
C'est très laid. Pourquoi essayez-vous d'utiliser le type de taille liés définit avec l'assembleur de toute façon? Si vous avez une architecture unique (inhérent à l'asm), alors il suffit d'écrire la constante littéralement. Il ne va pas changer!
Oh, c'est horrible, je l'avoue. 🙂 C'est une implémentation d'une fonction de la bibliothèque. Si j'avais à ma façon, je l'aurais écrit comme une constante directement..

OriginalL'auteur Sint
0

J'ai vu tout simplement d'alimentation de gcc le source assembleur vs gaz vous permettra de faire C comme les choses en assembleur. Il est en fait un peu peur quand vous venez à travers des situations où vous devez utiliser gcc comme un front-end pour le gaz pour obtenir quelque chose à travailler, mais c'est une autre histoire.

OriginalL'auteur old_timer
0

utilisation --cpreproc pour armasm option et ajouter
```
#include "my_arm.h"
```
en my_arm.s.

il travaille pour Keil BRAS

OriginalL'auteur netawater

Vous devez vous connecter pour publier un commentaire.