Définition de TYPE?

Question

INCLUDE Irvine32.inc 
.data 
array DWORD 10,20,30,40,50 
sum DWORD 0 

.code 
main PROC 

mov EDI,offset array 
mov ECX,5 
mov EAX,0 
HERE: 

add eax,[edi] 
add edi,TYPE array 
dec ecx 
jnz HERE 

mov sum,eax 

exit 
main ENDP 
END main 

Que signifie TYPE dans la ligne de la boucle: edi, tableau TYPE? Est-ce le TYPE de variable que nous utilisons dans le tableau qu'il remplace?

Answer 1

Ceci est le TYPE operator, qui renverra le type de l'expression est utilisée avec (dans ce cas particulier, array)

Pour référence en outre: MASM operators

Answer 2

TL; DR

TYPE retourne la taille, en octets, du type "représentant" d'une structure de données (un tel tableau).
SIZEOF retourne la taille, en octets, d'une structure de données.
LENGTHOF renvoie le nombre d'éléments dans une structure de données. Notez que ces opérateurs peuvent être appliqués à des types (par exemple BYTE) ou à des étiquettes (par exemple, TYPE myLabel).
Le résultat peut être différent pour les mêmes structures de données (par exemple des enregistrements).

La signification exacte est donnée ci-dessous. Notez qu'il existe un opérateur portant le même nom .TYPE qui peut être utilisé dans les macros pour renvoyer un champ de bits d'octets contenant des informations sur une expression (par exemple, il nomme un registre).
C'est ce qui est présenté par la documentation MASM mal écrite dans le MSDN.

Il ya un MASM 6.1 reference document here, je ne sais pas à quel point il fait autorité, mais toute cette réponse est basée sur elle.

---

Primitives

Ce document énumère TYPE comme un opérateur similaire à SIZEOF

Les SIZEOF et TYPE opérateurs, lorsqu'ils sont appliqués à un type , retourner la taille d'un entier de ce type.

L'attribut taille associée à chaque type de données est:

Data Type  Bytes 
    BYTE, SBYTE  1 
    WORD, SWORD  2 
    DWORD, SDWORD 4 
    FWORD   6 
    QWORD   8 
    TBYTE   10 

Ici, les opérateurs sont appliqués à un type, je crois qu'il est possible de les appliquer aux étiquettes associées aux primitives, entraînant la même sortie .

Arrays

Pour un tableau de la différence entre SIZEOF et TYPE (et LENGTHOF) devient clair:

L'opérateur LENGTHOF retourne le nombre d'éléments dans le tableau. L'opérateur SIZEOF renvoie le nombre d'octets utilisés par les initialiseurs dans la définition de tableau. TYPE renvoie la taille des éléments du tableau. Les exemples suivants illustrent ces opérateurs:

array WORD 40 DUP (5) 

larray EQU LENGTHOF array ; 40 elements 
sarray EQU SIZEOF array  ; 80 bytes 
tarray EQU TYPE array  ; 2 bytes per element 

Dans ce cas, les opérateurs sont utilisés avec des étiquettes.

Cordes

Pour cordes, il suffit de rappeler que les chaînes sont des tableaux d'octets.

Structures

Pour les structures, le concept est similaire aux tableaux: TYPE est la taille de la structure tandis que SIZEOF est la taille des tous les objets de structure associés à l'étiquette (MASM considérer une chose comme myLabel db 1, 2, 3 comme étant trois octets associés à myLabel):

la taille d'une structure déterminée par SIZEOF est le décalage du dernier champ, plus la taille du dernier champ , plus tout rembourrage requis pour un bon alignement.

INFO STRUCT 
buffer BYTE 100 DUP (?) 
crlf BYTE 13, 10 
query BYTE 'Filename: ' 
endmark BYTE 36 
drives DISKDRIVES <0, 1, 1> 
INFO ENDS 

;One struct 
info1 INFO { , , 'Dir' } 

;Three structs for this label 
lotsof INFO { , , 'file1', , {0,0,0} }, 
      { , , 'file2', , {0,0,1} }, 
      { , , 'file3', , {0,0,2} } 

sinfo1 EQU SIZEOF info1 ; 116 = number of bytes in initializers 
linfo1 EQU LENGTHOF info1 ; 1 = number of items 
tinfo1 EQU TYPE info1  ; 116 = same as size 

slotsof EQU SIZEOF lotsof ; 116 * 3 = number of bytes in initializers 
llotsof EQU LENGTHOF lotsof ; 3 = number of items 
tlotsof EQU TYPE lotsof  ; 116 = same as size for structure 
; of type INFO 

Dans ce cas, les opérateurs sont utilisés avec des étiquettes.

Les syndicats

Pour les syndicats, quelque chose de très semblable se produit:

La taille d'un syndicat déterminé par SIZEOF est la taille du champ le plus long, plus tout rembourrage nécessaire.
La longueur d'une variable d'union déterminée par LENGTHOF est égale au nombre d'initialiseurs définis entre chevrons ou entre accolades. TYPE renvoie une valeur indiquant le type du champ le plus long.

DWB UNION 
d DWORD ? 
w WORD ? 
b BYTE ? 
DWB ENDS 

num DWB {0FFFFh} 
array DWB (100/SIZEOF DWB) DUP ({0}) 

snum EQU SIZEOF num  ; = 4 
lnum EQU LENGTHOF num  ; = 1 
tnum EQU TYPE num   ; = 4 

sarray EQU SIZEOF array ; = 100 (4*25) 
larray EQU LENGTHOF array ; = 25 
tarray EQU TYPE array  ; = 4 

Dans ce cas, les opérateurs sont utilisés avec des étiquettes.

Enregistre

enregistrements sont des octets, des mots ou dans lesquels les doubles mots bits individuels ou groupes de bits sont considérés comme des champs. ^{Cité dans le manuel, mais pas formatée comme un devis intentionnellement.}

Les opérateurs SIZEOF et TYPE appliqués à un nom d'enregistrement renvoient le nombre d'octets utilisés par le dossier . SIZEOF renvoie le nombre d'octets occupés par une variable d'enregistrement. Vous ne pouvez pas utiliser LENGTHOF avec une déclaration d'enregistrement, mais vous pouvez l'utiliser avec des variables d'enregistrement définies. LENGTHOF renvoie le nombre d'enregistrements dans un tableau d'enregistrements, ou 1 pour une variable d'enregistrement unique. L'exemple suivant illustre ces points.

; Record definition 
; 9 bits stored in 2 bytes 
RGBCOLOR RECORD red:3, green:3, blue:3 

mov ax, RGBCOLOR    ; Equivalent to "mov ax, 01FFh" 
; mov ax, LENGTHOF RGBCOLOR ; Illegal since LENGTHOF can 
           ; apply only to data label 
mov ax, SIZEOF RGBCOLOR  ; Equivalent to "mov ax, 2" 
mov ax, TYPE RGBCOLOR   ; Equivalent to "mov ax, 2" 

; Record instance 
; 8 bits stored in 1 byte 
RGBCOLOR2 RECORD red:3, green:3, blue:2 
rgb RGBCOLOR2 <1, 1, 1> ; Initialize to 00100101y 

mov ax, RGBCOLOR2  ; Equivalent to "mov ax, 00FFh" 
mov ax, LENGTHOF rgb ; Equivalent to "mov ax, 1" 
mov ax, SIZEOF rgb ; Equivalent to "mov ax, 1" 
mov ax, TYPE rgb  ; Equivalent to "mov ax, 1" 

Ici, il y a une petite asymétrie lors de l'utilisation des opérateurs avec des étiquettes et des types.

---

.TYPE comme opérateur pour les macros

Cet opérateur est l'ancienne version de OPATTR et retourne un octet avec le contenu suivant:

Bit Set If expression 
0  References a code label 
1  Is a memory variable or has a relocatable data label 
2  Is an immediate value 
3  Uses direct memory addressing 
4  Is a register value 
5  References no undefined symbols and is without error 
6  Is relative to SS 
7  References an external label 

Cela a un goût de métaprogrammation et il est normalement utilisé pour optimiser le code généré avec les macros.