callt function (#pragma callt)

This notifies the compiler of a callt function.

[Function]

-	A function specified with #pragma callt is called by the callt instruction. The callt instruction enables a function whose "start address of function definition" is stored in the area (0x80 to 0xBF) called as the callt instruction table to be called by a shorter code than a direct function call.

-	The callt function is called by the callt instruction using a label name with "@_" added to the beginning of the function name. When the callt function is called at the end of a function, the callt instruction is not used to make the call in some cases.

-	The called function is handled as a normal function in the C source program.

-	The specification becomes __near, and address reference always returns a near pointer.

-	The callt function is allocated to a section with the relocation attribute TEXT.

-	The callt instruction table is allocated to the .callt0 section.

-	#pragma callt handles even a variable to which the __far keyword is added as if __near was specified without a warning being output.

-	When #pragma callt, #pragma near, or #pragma far was specified together for the same function, the #pragma directives become valid in the priority order of #pragma callt > #pragma near > #pragma far.

[Effect]

-	The size of the object code becomes smaller because the function is called by a 2-byte call instruction.

[Usage]

-	Declare #pragma callt before the first declaration of a variable.

#pragma callt [(]function-name[,...][)]

[Restrictions]

-	If there are multiple declarations for the same variable and #pragma callt is written at the location where the second or subsequent declaration takes effect, correct operation is not guaranteed. #pragma callt should be written before the declaration.

-	If a #pragma directive other than #pragma near or #pragma far is specified for the same function, a compilation error will occur.

-	If __inline and __callt are specified in the declaration of a target function of this #pragma directive, a compilation error will occur.

[Example]

#pragma callt callt_func1

extern void callt_func1(void);

void func1(void)

        callt_func1();

#pragma callt callt_func2

extern void __far callt_func2(void);  // Becomes __near without a warning

                                      // due to the effect of #pragma callt

void func2(void)

        callt_func2();

[Remark]

-	Difference between the __callt keyword and #pragma callt

-	The __callt keyword cannot be used together with the __far keyword, and a compilation error will occur if used so.

-	#pragma callt handles even a function to which the __far keyword is added as if __callt was specified without a warning being output.