__declspec(code_seg)

Section spécifique à Microsoft

L’attribut code_seg de déclaration nomme un segment de texte exécutable dans le .obj fichier dans lequel le code objet des fonctions membres de la fonction ou de la classe est stocké.

Syntaxe

__declspec(code_seg("segname")) declarator

Notes

L'attribut __declspec(code_seg(...)) permet de placer le code dans des blocs nommés distincts qui peuvent être paginés ou verrouillés individuellement en mémoire. Vous pouvez utiliser cet attribut pour contrôler l'emplacement des modèles instanciés et du code généré par le compilateur.

Un segment est un bloc nommé de données dans un .obj fichier chargé en mémoire en tant qu’unité. Un segment de texte est un segment qui contient du code exécutable. La section de terme est souvent utilisée de façon interchangeable avec le segment.

Le code objet qui est généré lorsque declarator est défini est placé dans le segment de texte spécifié par segname, qui est un littéral de chaîne étroite. Le nom segname n’a pas à être spécifié dans un pragma de section avant de pouvoir être utilisé dans une déclaration. Par défaut, lorsqu’aucun n’est code_seg spécifié, le code objet est placé dans un segment nommé .text. Un code_seg attribut remplace toute directive #pragma code_seg existante. Un code_seg attribut appliqué à une fonction membre remplace tout code_seg attribut appliqué à la classe englobante.

Si une entité a un code_seg attribut, toutes les déclarations et définitions de la même entité doivent avoir des attributs identiques code_seg . Si une classe de base a un code_seg attribut, les classes dérivées doivent avoir le même attribut.

Lorsqu’un code_seg attribut est appliqué à une fonction d’étendue d’espace de noms ou à une fonction membre, le code objet de cette fonction est placé dans le segment de texte spécifié. Lorsque cet attribut est appliqué à une classe, toutes les fonctions membres de la classe et des classes imbriquées, y compris les fonctions membres spéciales générées par le compilateur, sont placées dans le segment spécifié. Les classes définies localement( par exemple, les classes définies dans un corps de fonction membre) n’héritent pas de l’attribut code_seg de l’étendue englobante.

Lorsqu’un code_seg attribut est appliqué à un modèle de classe ou à un modèle de fonction, toutes les spécialisations implicites du modèle sont placées dans le segment spécifié. Les spécialisations explicites ou partielles n’héritent pas de l’attribut code_seg du modèle principal. Vous pouvez spécifier le même attribut ou un autre code_seg attribut sur la spécialisation. Un code_seg attribut ne peut pas être appliqué à une instanciation de modèle explicite.

Par défaut, le code généré par le compilateur, tel qu’une fonction membre spéciale, est placé dans le .text segment. La #pragma code_seg directive ne remplace pas cette valeur par défaut. Utilisez l’attribut sur la classe, le code_seg modèle de classe ou le modèle de fonction pour contrôler où le code généré par le compilateur est placé.

Les lambda héritent code_seg des attributs de leur étendue englobante. Pour spécifier un segment pour une expression lambda, appliquez un code_seg attribut après la clause de déclaration de paramètre et avant toute spécification mutable ou exception, toute spécification de type de retour de fin et le corps lambda. Pour plus d’informations, consultez Syntaxe d’expression lambda. Cet exemple définit une expression lambda dans un segment nommé PagedMem :

auto Sqr = [](int t) __declspec(code_seg("PagedMem")) -> int { return t*t; };

Faites attention lorsque vous placez des fonctions membres dans plusieurs segments, en particulier les fonctions membres virtuelles. Supposons que vous définissez une fonction virtuelle dans une classe dérivée qui réside dans un segment paginé lorsque la méthode de classe de base réside dans un segment non paginé. D’autres méthodes de classe de base ou code utilisateur peuvent supposer que l’appel de la méthode virtuelle ne déclenche pas d’erreur de page.

Exemple

Cet exemple montre comment un code_seg attribut contrôle l’emplacement des segments lorsque la spécialisation de modèle implicite et explicite est utilisée :

// code_seg.cpp
// Compile: cl /EHsc /W4 code_seg.cpp

// Base template places object code in Segment_1 segment
template<class T>
class __declspec(code_seg("Segment_1")) Example
{
public:
   virtual void VirtualMemberFunction(T /*arg*/) {}
};

// bool specialization places code in default .text segment
template<>
class Example<bool>
{
public:
   virtual void VirtualMemberFunction(bool /*arg*/) {}
};

// int specialization places code in Segment_2 segment
template<>
class __declspec(code_seg("Segment_2")) Example<int>
{
public:
   virtual void VirtualMemberFunction(int /*arg*/) {}
};

// Compiler warns and ignores __declspec(code_seg("Segment_3"))
// in this explicit specialization
__declspec(code_seg("Segment_3")) Example<short>; // C4071

int main()
{
   // implicit double specialization uses base template's
   // __declspec(code_seg("Segment_1")) to place object code
   Example<double> doubleExample{};
   doubleExample.VirtualMemberFunction(3.14L);

   // bool specialization places object code in default .text segment
   Example<bool> boolExample{};
   boolExample.VirtualMemberFunction(true);

   // int specialization uses __declspec(code_seg("Segment_2"))
   // to place object code
   Example<int> intExample{};
   intExample.VirtualMemberFunction(42);
}

FIN de la section spécifique à Microsoft

Voir aussi

__declspec
Mots clés