Файл pkg.ads:

package Pkg is
 
type Alpha is abstract tagged record
	data_alpha : Integer;
end record;
procedure func_alpha (x: in out Alpha) is abstract;
 
type Beta is interface;
procedure func_beta (x: in out Beta) is abstract;
 
type Gamma is new Alpha and Beta with record
	data_gamma : Integer;
end record;
procedure func_alpha (x: in out Gamma);
procedure func_beta (x: in out Gamma);
procedure func_gamma (x: in out Gamma);
 
end Pkg;

Файл pkg.adb:

with System.Machine_Code; use System.Machine_Code;
 
package body Pkg is
 
procedure func_gamma (x: in out Gamma) is
begin
	asm ("# func_gamma");
	x.data_gamma := 1;
end func_gamma;
 
procedure func_beta (x: in out Gamma) is
begin
	asm ("# func_beta");
end func_beta;
 
procedure func_alpha (x: in out Gamma) is
begin
	asm ("# func_alpha");
	x.data_alpha := 1;
end func_alpha;
 
end Pkg;

gcc -gnat05 -O -S pkg.adb

Файл gnat.adc:

pragma No_Run_Time;
 
pragma Restrictions (No_Enumeration_Maps);
--  This restriction ensures at compile time that no operations
--  requiring enumeration maps are used (that is Image and Value
--  attributes applied to enumeration types).
 
pragma Restrictions (No_Secondary_Stack);
--  This restriction ensures at compile time that the generated code
--  does not contain any reference to the secondary stack. The
--  secondary stack is used to implement functions returning
--  unconstrained objects (arrays or records) on some targets. The
--  details and use of this restriction are described in more detail
--  in the High Integrity product documentation.
 
pragma Restrictions (Static_Priorities);
--  This restriction ensures at compile time that all priority
--  expressions are static, and that there are no dependencies on the
--  package Ada.Dynamic_Priorities.
 
pragma Restrictions (Static_Storage_Size);
--  This restriction ensures at compile time that any expression
--  appearing in a Storage_Size pragma or attribute definition clause
--  is static.
 
pragma Restrictions (No_Implicit_Heap_Allocations);
-- There are no operations that implicitly require heap storage allocation
-- to be performed by the implementation. The operations that implicitly
-- require heap storage allocation are implementation defined.

	.file	"pkg.adb"
	.text
.globl pkg__alphaIP
	.type	pkg__alphaIP, @function
pkg__alphaIP:
	pushl	%ebp
	movl	%esp, %ebp
	cmpb	$0, 12(%ebp)
	je	.L4
	movl	pkg__alphaP, %edx
	movl	8(%ebp), %eax
	movl	%edx, (%eax)
.L4:
	popl	%ebp
	ret
	.size	pkg__alphaIP, .-pkg__alphaIP
.globl pkg___alignment
	.type	pkg___alignment, @function
pkg___alignment:
	pushl	%ebp
	movl	%esp, %ebp
	movl	$4, %eax
	popl	%ebp
	ret
	.size	pkg___alignment, .-pkg___alignment
.globl pkg___size
	.type	pkg___size, @function
pkg___size:
	pushl	%ebp
	movl	%esp, %ebp
	movl	$64, %eax
	movl	$0, %edx
	popl	%ebp
	ret
	.size	pkg___size, .-pkg___size
.globl pkg__Oeq
	.type	pkg__Oeq, @function
pkg__Oeq:
	pushl	%ebp
	movl	%esp, %ebp
	movl	8(%ebp), %eax
	movl	4(%eax), %edx
	movl	12(%ebp), %eax
	cmpl	4(%eax), %edx
	sete	%al
	popl	%ebp
	ret
	.size	pkg__Oeq, .-pkg__Oeq
.globl pkg___assign
	.type	pkg___assign, @function
pkg___assign:
	pushl	%ebp
	movl	%esp, %ebp
	pushl	%ebx
	movl	8(%ebp), %ecx
	movl	12(%ebp), %ebx
	cmpl	%ebx, %ecx
	je	.L14
	movl	(%ecx), %eax
	movl	(%ebx), %edx
	movl	%edx, (%ecx)
	movl	4(%ebx), %edx
	movl	%edx, 4(%ecx)
	movl	%eax, (%ecx)
.L14:
	popl	%ebx
	popl	%ebp
	ret
	.size	pkg___assign, .-pkg___assign
.globl pkg__betaIP
	.type	pkg__betaIP, @function
pkg__betaIP:
	pushl	%ebp
	movl	%esp, %ebp
	cmpb	$0, 12(%ebp)
	je	.L18
	movl	pkg__betaP, %edx
	movl	8(%ebp), %eax
	movl	%edx, (%eax)
.L18:
	popl	%ebp
	ret
	.size	pkg__betaIP, .-pkg__betaIP
.globl pkg___alignment__2
	.type	pkg___alignment__2, @function
pkg___alignment__2:
	pushl	%ebp
	movl	%esp, %ebp
	movl	$4, %eax
	popl	%ebp
	ret
	.size	pkg___alignment__2, .-pkg___alignment__2
.globl pkg___size__2
	.type	pkg___size__2, @function
pkg___size__2:
	pushl	%ebp
	movl	%esp, %ebp
	movl	$32, %eax
	movl	$0, %edx
	popl	%ebp
	ret
	.size	pkg___size__2, .-pkg___size__2
.globl pkg__Oeq__2
	.type	pkg__Oeq__2, @function
pkg__Oeq__2:
	pushl	%ebp
	movl	%esp, %ebp
	movb	$1, %al
	popl	%ebp
	ret
	.size	pkg__Oeq__2, .-pkg__Oeq__2
.globl pkg___assign__2
	.type	pkg___assign__2, @function
pkg___assign__2:
	pushl	%ebp
	movl	%esp, %ebp
	popl	%ebp
	ret
	.size	pkg___assign__2, .-pkg___assign__2
.globl pkg___alignment__3
	.type	pkg___alignment__3, @function
pkg___alignment__3:
	pushl	%ebp
	movl	%esp, %ebp
	movl	$4, %eax
	popl	%ebp
	ret
	.size	pkg___alignment__3, .-pkg___alignment__3
.globl pkg__T548s
	.type	pkg__T548s, @function
pkg__T548s:
	pushl	%ebp
	movl	%esp, %ebp
	subl	$4, %esp
	movl	8(%ebp), %eax
	subl	$8, %eax
	movl	%eax, (%esp)
	call	pkg___alignment__3
	leave
	ret
	.size	pkg__T548s, .-pkg__T548s
.globl pkg___size__3
	.type	pkg___size__3, @function
pkg___size__3:
	pushl	%ebp
	movl	%esp, %ebp
	movl	$128, %eax
	movl	$0, %edx
	popl	%ebp
	ret
	.size	pkg___size__3, .-pkg___size__3
.globl pkg__T539s
	.type	pkg__T539s, @function
pkg__T539s:
	pushl	%ebp
	movl	%esp, %ebp
	subl	$4, %esp
	movl	8(%ebp), %eax
	subl	$8, %eax
	movl	%eax, (%esp)
	call	pkg___size__3
	leave
	ret
	.size	pkg__T539s, .-pkg__T539s
.globl pkg__Oeq__3
	.type	pkg__Oeq__3, @function
pkg__Oeq__3:
	pushl	%ebp
	movl	%esp, %ebp
	subl	$16, %esp
	movl	%ebx, -8(%ebp)
	movl	%esi, -4(%ebp)
	movl	8(%ebp), %ebx
	movl	12(%ebp), %esi
	movl	%esi, 4(%esp)
	movl	%ebx, (%esp)
	call	pkg__Oeq
	testb	%al, %al
	je	.L38
	movl	8(%ebx), %eax
	cmpl	8(%esi), %eax
	jne	.L38
	movl	12(%ebx), %eax
	cmpl	12(%esi), %eax
	sete	%al
	jmp	.L41
.L38:
	movb	$0, %al
.L41:
	movl	-8(%ebp), %ebx
	movl	-4(%ebp), %esi
	movl	%ebp, %esp
	popl	%ebp
	ret
	.size	pkg__Oeq__3, .-pkg__Oeq__3
.globl pkg__T557s
	.type	pkg__T557s, @function
pkg__T557s:
	pushl	%ebp
	movl	%esp, %ebp
	subl	$8, %esp
	movl	12(%ebp), %eax
	movl	%eax, 4(%esp)
	movl	8(%ebp), %eax
	subl	$8, %eax
	movl	%eax, (%esp)
	call	pkg__Oeq__3
	leave
	ret
	.size	pkg__T557s, .-pkg__T557s
.globl pkg___assign__3
	.type	pkg___assign__3, @function
pkg___assign__3:
	pushl	%ebp
	movl	%esp, %ebp
	pushl	%ebx
	movl	8(%ebp), %ecx
	movl	12(%ebp), %ebx
	cmpl	%ebx, %ecx
	je	.L48
	movl	(%ecx), %edx
	movl	(%ebx), %eax
	movl	%eax, (%ecx)
	movl	4(%ebx), %eax
	movl	%eax, 4(%ecx)
	movl	8(%ebx), %eax
	movl	%eax, 8(%ecx)
	movl	12(%ebx), %eax
	movl	%eax, 12(%ecx)
	movl	%edx, (%ecx)
.L48:
	popl	%ebx
	popl	%ebp
	ret
	.size	pkg___assign__3, .-pkg___assign__3
.globl pkg__T566s
	.type	pkg__T566s, @function
pkg__T566s:
	pushl	%ebp
	movl	%esp, %ebp
	subl	$8, %esp
	movl	12(%ebp), %eax
	movl	%eax, 4(%esp)
	movl	8(%ebp), %eax
	subl	$8, %eax
	movl	%eax, (%esp)
	call	pkg___assign__3
	leave
	ret
	.size	pkg__T566s, .-pkg__T566s
.globl pkg__func_gamma
	.type	pkg__func_gamma, @function
pkg__func_gamma:
	pushl	%ebp
	movl	%esp, %ebp
#APP
	# func_gamma
#NO_APP
	movl	8(%ebp), %eax
	movl	$1, 12(%eax)
	popl	%ebp
	ret
	.size	pkg__func_gamma, .-pkg__func_gamma
.globl pkg__func_beta__2
	.type	pkg__func_beta__2, @function
pkg__func_beta__2:
	pushl	%ebp
	movl	%esp, %ebp
#APP
	# func_beta
#NO_APP
	popl	%ebp
	ret
	.size	pkg__func_beta__2, .-pkg__func_beta__2
.globl pkg__T578s
	.type	pkg__T578s, @function
pkg__T578s:
	pushl	%ebp
	movl	%esp, %ebp
	popl	%ebp
	ret
	.size	pkg__T578s, .-pkg__T578s
.globl pkg__func_alpha__2
	.type	pkg__func_alpha__2, @function
pkg__func_alpha__2:
	pushl	%ebp
	movl	%esp, %ebp
#APP
	# func_alpha
#NO_APP
	movl	8(%ebp), %eax
	movl	$1, 4(%eax)
	popl	%ebp
	ret
	.size	pkg__func_alpha__2, .-pkg__func_alpha__2
.globl pkg___elabs
	.type	pkg___elabs, @function
pkg___elabs:
	pushl	%ebp
	movl	%esp, %ebp
	pushl	%edi
	pushl	%esi
	pushl	%ebx
	movb	$1, pkg__alphaT
	movb	$2, pkg__alphaT+1
	cmpb	$0, pkg__alphaF
	je	.L60
	movl	pkg__alphaP, %eax
	movl	$pkg__alphaB, -4(%eax)
	movl	pkg__alphaP, %eax
	cmpb	$2, -11(%eax)
	jne	.L62
	movl	-4(%eax), %eax
	movl	$16, 28(%eax)
	jmp	.L64
.L62:
	movl	-4(%eax), %eax
	movl	$16, 4(%eax)
.L64:
	movl	pkg__alphaP, %eax
	movl	-4(%eax), %eax
	movl	$pkg__alphaE, 8(%eax)
	movl	pkg__alphaP, %eax
	movl	-4(%eax), %eax
	movl	$0, 4(%eax)
	movl	pkg__alphaP, %eax
	movl	-4(%eax), %eax
	movl	$0, (%eax)
	movl	$0, 32(%eax)
	movl	pkg__alphaP, %edx
	movl	%edx, 40(%eax)
	movl	pkg__alphaP, %eax
	movl	-4(%eax), %eax
	movl	$0, 24(%eax)
	movl	pkg__alphaP, %eax
	movl	-4(%eax), %eax
	movb	$0, 20(%eax)
	movl	pkg__alphaP, %eax
	movl	$0, -8(%eax)
	movl	pkg__alphaP, %eax
	movl	-4(%eax), %eax
	movl	$pkg__alphaE, 12(%eax)
	movb	$0, pkg__alphaF
.L60:
	movl	pkg__alphaP, %eax
	movl	$pkg___size, (%eax)
	movl	pkg__alphaP, %eax
	movl	$pkg___alignment, 4(%eax)
	movl	pkg__alphaP, %eax
	movl	$pkg__Oeq, 24(%eax)
	movl	pkg__alphaP, %eax
	movl	$pkg___assign, 28(%eax)
	movb	$1, pkg__betaT
	movb	$4, pkg__betaT+1
	cmpb	$0, pkg__betaF
	je	.L65
	movl	pkg__betaP, %eax
	movl	$pkg__betaB, -4(%eax)
	movl	pkg__betaP, %eax
	movl	-4(%eax), %eax
	movl	$pkg__betaE, 8(%eax)
	movl	pkg__betaP, %eax
	movl	-4(%eax), %eax
	movl	$0, (%eax)
	movl	$0, 32(%eax)
	movl	pkg__betaP, %edx
	movl	%edx, 40(%eax)
	movl	pkg__betaP, %eax
	movl	-4(%eax), %eax
	movl	$pkg__betaE, 12(%eax)
	movb	$0, pkg__betaF
.L65:
	movb	$1, pkg__T281s
	movb	$3, pkg__T281s+1
	movl	$1, pkg__I282s
	movl	pkg__pkg__gamma0P, %eax
	movl	$pkg__I282s, -4(%eax)
	movl	pkg__pkg__gamma0P, %eax
	cmpb	$2, -11(%eax)
	jne	.L67
	movl	-4(%eax), %eax
	movl	$16, 28(%eax)
	jmp	.L69
.L67:
	movl	-4(%eax), %eax
	movl	$16, 4(%eax)
.L69:
	movb	$1, pkg__gammaT
	movb	$2, pkg__gammaT+1
	cmpb	$0, pkg__gammaF
	je	.L70
	movl	pkg__gammaP, %eax
	movl	$pkg__gammaB, -4(%eax)
	movl	pkg__gammaP, %eax
	cmpb	$2, -11(%eax)
	jne	.L72
	movl	-4(%eax), %eax
	movl	$18, 28(%eax)
	jmp	.L74
.L72:
	movl	-4(%eax), %eax
	movl	$18, 4(%eax)
.L74:
	movl	pkg__gammaP, %eax
	movl	-4(%eax), %eax
	movl	$pkg__gammaE, 8(%eax)
	movl	pkg__gammaP, %eax
	movl	-4(%eax), %eax
	movl	$0, 4(%eax)
	movl	pkg__alphaP, %esi
	testl	%esi, %esi
	je	.L75
	movl	pkg__gammaP, %edi
	cld
	movl	$16, %ecx
	rep
	movsl
	movl	pkg__gammaP, %eax
	movl	-4(%eax), %esi
	movl	pkg__alphaP, %eax
	testl	%eax, %eax
	je	.L77
	movl	-4(%eax), %edi
	movl	(%edi), %eax
	incl	%eax
	movl	%eax, (%esi)
	movl	32(%edi), %eax
	movl	%eax, 32(%esi)
	addl	(%esi), %eax
	movl	(%edi), %ebx
	movl	32(%edi), %ecx
	testl	%eax, %eax
	jle	.L79
	movl	%eax, %edx
	leal	(%ebx,%ecx), %ecx
.L81:
	movl	40(%edi,%ecx,4), %eax
	movl	%eax, 40(%esi,%edx,4)
	decl	%ecx
	decl	%edx
	je	.L79
	jmp	.L81
.L77:
	movl	$0, (%esi)
	movl	$0, 32(%esi)
.L79:
	movl	pkg__gammaP, %eax
	movl	%eax, 40(%esi)
	movl	pkg__gammaP, %eax
	movl	-4(%eax), %eax
	movl	$0, 24(%eax)
	movl	pkg__gammaP, %eax
	movl	-4(%eax), %eax
	movb	$0, 20(%eax)
	movl	pkg__gammaP, %eax
	movl	$0, -8(%eax)
	movl	pkg__gammaP, %eax
	movl	-4(%eax), %eax
	movl	$pkg__gammaE, 12(%eax)
	movb	$0, pkg__gammaF
.L70:
	movl	pkg__gammaP, %eax
	movl	-4(%eax), %edi
	movl	32(%edi), %ebx
	testl	%ebx, %ebx
	jle	.L82
	movl	(%edi), %eax
	leal	1(%eax), %edx
	leal	(%ebx,%eax), %esi
	movl	pkg__betaP, %ecx
	leal	40(%edi,%eax,4), %eax
.L84:
	cmpl	%ecx, 4(%eax)
	je	.L85
	incl	%edx
	addl	$4, %eax
	cmpl	%esi, %edx
	jle	.L84
.L82:
	leal	1(%ebx), %eax
	movl	%eax, 32(%edi)
	addl	(%edi), %eax
	movl	pkg__betaP, %edx
	movl	%edx, 40(%edi,%eax,4)
.L85:
	movl	pkg__gammaP, %eax
	movl	$pkg___size__3, (%eax)
	movl	pkg__pkg__gamma0P, %eax
	movl	$pkg__T539s, (%eax)
	movl	pkg__gammaP, %eax
	movl	$pkg___alignment__3, 4(%eax)
	movl	pkg__pkg__gamma0P, %eax
	movl	$pkg__T548s, 4(%eax)
	movl	pkg__gammaP, %eax
	movl	$pkg__Oeq__3, 24(%eax)
	movl	pkg__pkg__gamma0P, %eax
	movl	$pkg__T557s, 24(%eax)
	movl	pkg__gammaP, %eax
	movl	$pkg___assign__3, 28(%eax)
	movl	pkg__pkg__gamma0P, %eax
	movl	$pkg__T566s, 28(%eax)
	movl	pkg__gammaP, %eax
	movl	$pkg__func_beta__2, 64(%eax)
	movl	pkg__pkg__gamma0P, %eax
	movl	$pkg__T578s, 60(%eax)
	movl	pkg__pkg__gamma0P, %eax
	movl	pkg__gammaP, %esi
	testl	%esi, %esi
	je	.L87
	cld
	movl	$15, %ecx
	movl	%eax, %edi
	rep
	movsl
.L87:
	movl	pkg__gammaP, %eax
	movl	$pkg__func_alpha__2, 60(%eax)
	movl	pkg__gammaP, %eax
	movl	$pkg__func_gamma, 68(%eax)
	popl	%ebx
	popl	%esi
	popl	%edi
	popl	%ebp
	ret
.L75:
	movl	pkg__gammaP, %eax
	movl	-4(%eax), %esi
	jmp	.L77
	.size	pkg___elabs, .-pkg___elabs
.globl pkg__gammaIP
	.type	pkg__gammaIP, @function
pkg__gammaIP:
	pushl	%ebp
	movl	%esp, %ebp
	movl	8(%ebp), %edx
	cmpb	$0, 12(%ebp)
	je	.L92
	movl	pkg__gammaP, %eax
	movl	%eax, (%edx)
.L92:
	movl	pkg__pkg__gamma0P, %eax
	movl	%eax, 8(%edx)
	movl	pkg__pkg__gamma0P, %eax
	movl	$8, -8(%eax)
	popl	%ebp
	ret
	.size	pkg__gammaIP, .-pkg__gammaIP
.globl pkg_E
	.data
	.type	pkg_E, @object
	.size	pkg_E, 1
pkg_E:
	.zero	1
.globl pkg__alphaT
	.bss
	.align 32
	.type	pkg__alphaT, @object
	.size	pkg__alphaT, 76
pkg__alphaT:
	.zero	76
.globl pkg__alphaP
	.data
	.align 4
	.type	pkg__alphaP, @object
	.size	pkg__alphaP, 4
pkg__alphaP:
	.long	pkg__alphaT+12
.globl pkg__alphaF
	.type	pkg__alphaF, @object
	.size	pkg__alphaF, 1
pkg__alphaF:
	.byte	1
.globl pkg__alphaB
	.bss
	.align 32
	.type	pkg__alphaB, @object
	.size	pkg__alphaB, 44
pkg__alphaB:
	.zero	44
.globl pkg__alphaE
	.data
	.type	pkg__alphaE, @object
	.size	pkg__alphaE, 10
pkg__alphaE:
	.string	"PKG.ALPHA"
.globl pkg__betaT
	.bss
	.align 4
	.type	pkg__betaT, @object
	.size	pkg__betaT, 16
pkg__betaT:
	.zero	16
.globl pkg__betaP
	.data
	.align 4
	.type	pkg__betaP, @object
	.size	pkg__betaP, 4
pkg__betaP:
	.long	pkg__betaT+12
.globl pkg__betaF
	.type	pkg__betaF, @object
	.size	pkg__betaF, 1
pkg__betaF:
	.byte	1
.globl pkg__betaB
	.bss
	.align 32
	.type	pkg__betaB, @object
	.size	pkg__betaB, 40
pkg__betaB:
	.zero	40
.globl pkg__betaE
	.data
	.type	pkg__betaE, @object
	.size	pkg__betaE, 9
pkg__betaE:
	.string	"PKG.BETA"
.globl pkg__T281s
	.bss
	.align 32
	.type	pkg__T281s, @object
	.size	pkg__T281s, 76
pkg__T281s:
	.zero	76
.globl pkg__pkg__gamma0P
	.data
	.align 4
	.type	pkg__pkg__gamma0P, @object
	.size	pkg__pkg__gamma0P, 4
pkg__pkg__gamma0P:
	.long	pkg__T281s+12
.globl pkg__I282s
	.bss
	.align 4
	.type	pkg__I282s, @object
	.size	pkg__I282s, 12
pkg__I282s:
	.zero	12
.globl pkg__gammaT
	.align 32
	.type	pkg__gammaT, @object
	.size	pkg__gammaT, 84
pkg__gammaT:
	.zero	84
.globl pkg__gammaP
	.data
	.align 4
	.type	pkg__gammaP, @object
	.size	pkg__gammaP, 4
pkg__gammaP:
	.long	pkg__gammaT+12
.globl pkg__gammaF
	.type	pkg__gammaF, @object
	.size	pkg__gammaF, 1
pkg__gammaF:
	.byte	1
.globl pkg__gammaB
	.bss
	.align 32
	.type	pkg__gammaB, @object
	.size	pkg__gammaB, 52
pkg__gammaB:
	.zero	52
.globl pkg__gammaE
	.data
	.type	pkg__gammaE, @object
	.size	pkg__gammaE, 10
pkg__gammaE:
	.string	"PKG.GAMMA"
	.ident	"GCC: (GNU) 4.1.1"
	.section	.note.GNU-stack,"",@progbits