__declspec(code_seg)

Específicos de Microsoft

El code_seg atributo de declaración asigna un nombre a un segmento de texto ejecutable en el .obj archivo en el que se almacena el código de objeto para las funciones miembro de función o clase.

Sintaxis

__declspec(code_seg("segname")) declarator

Comentarios

El atributo __declspec(code_seg(...)) permite colocar código en segmentos con nombre diferentes que se pueden paginar o bloquear en memoria individualmente. Este atributo se puede usar para controlar la posición de las plantillas con instancia y del código generado por el compilador.

Un segmento es un bloque con nombre de datos en un .obj archivo que se carga en la memoria como una unidad. Un segmento de texto es un segmento que contiene código ejecutable. El término sección se suele usar indistintamente con el término segmento.

El código objeto que se genera cuando se define declarator se coloca en el segmento de texto especificado por segname, que es un literal de cadena de caracteres estrechos. El nombre segname no tiene que especificarse en una pragma de sección para poder usarlo en una declaración. De forma predeterminada, cuando no se especifica ningún code_seg , el código de objeto se coloca en un segmento denominado .text. Un code_seg atributo invalida cualquier directiva de #pragma code_seg existente. Un code_seg atributo aplicado a una función miembro invalida cualquier code_seg atributo aplicado a la clase envolvente.

Si una entidad tiene un code_seg atributo , todas las declaraciones y definiciones de la misma entidad deben tener atributos idénticos code_seg . Si una clase base tiene un code_seg atributo , las clases derivadas deben tener el mismo atributo.

Cuando se aplica un code_seg atributo a una función de ámbito de espacio de nombres o a una función miembro, el código de objeto de esa función se coloca en el segmento de texto especificado. Cuando este atributo se aplica a una clase, todas las funciones miembro de la clase y las clases anidadas ,incluidas las funciones miembro especiales generadas por el compilador, se colocan en el segmento especificado. Las clases definidas localmente (por ejemplo, las clases definidas en un cuerpo de función miembro) no heredan el code_seg atributo del ámbito envolvente.

Cuando se aplica un code_seg atributo a una plantilla de clase o a una plantilla de función, todas las especializaciones implícitas de la plantilla se colocan en el segmento especificado. Las especializaciones explícitas o parciales no heredan el code_seg atributo de la plantilla principal. Puede especificar el mismo atributo o otro code_seg en la especialización. Un code_seg atributo no se puede aplicar a una creación de instancias de plantilla explícita.

De forma predeterminada, el código generado por el compilador, como una función miembro especial, se coloca en el .text segmento. La #pragma code_seg directiva no invalida este valor predeterminado. Use el code_seg atributo de la clase, la plantilla de clase o la plantilla de función para controlar dónde se coloca el código generado por el compilador.

Las expresiones lambda heredan code_seg los atributos de su ámbito envolvente. Para especificar un segmento para una expresión lambda, aplique un code_seg atributo después de la cláusula parameter-declaration y antes de cualquier especificación mutable o exception, cualquier especificación de tipo devuelto final y el cuerpo lambda. Para obtener más información, vea Sintaxis de la expresión lambda. En este ejemplo se define una expresión lambda en un segmento denominado PagedMem:

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

Tenga cuidado cuando coloque determinadas funciones miembro, especialmente funciones miembro virtuales, en segmentos diferentes. Supongamos que define una función virtual en una clase derivada que reside en un segmento paginado cuando el método de clase base reside en un segmento no paginado. Otros métodos de clase base o código de usuario pueden suponer que invocar el método virtual no desencadenará un error de página.

Ejemplo

En este ejemplo se muestra cómo un atributo controla la code_seg colocación de segmentos cuando se usa la especialización implícita y explícita de plantillas:

// 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 Específicos de Microsoft

Consulte también

__declspec
Palabras clave