index : openwrt/upstream	attitude_adjustment barrier_breaker chaos_calmer lede-17.01 less-old-master master old-master openwrt-18.06 openwrt-19.07 upstream
	upstream openwrt	James

aboutsummaryrefslogtreecommitdiffstats

log msg author committer range

path: root/include/package-defaults.mk

	Commit message (Expand)	Author	Age	Files	Lines
*	add special handling for the adm5120 target, which uses subtargets for differ...	Imre Kaloz	2009-08-03	1	-1/+5
*	revert 17050 this was not the right way to fix this	Florian Fainelli	2009-08-01	1	-3/+3
*	use board names instead of arch in packages	Imre Kaloz	2009-07-31	1	-1/+1
*	move the global ipv6 option to the very bottom of the options passed to confi...	Florian Fainelli	2009-07-30	1	-3/+3
*	globally define IPv6 support or not in OpenWrt, just like for largefiles, ipv...	Florian Fainelli	2009-07-25	1	-1/+3
*	Fix configure script path when not at the root of $(PKG_BUILD_DIR), thanks Da...	Florian Fainelli	2009-07-02	1	-1/+1
*	add dist and distcheck target (to create new source balls)	Ralph Hempel	2009-05-31	1	-1/+9
*	remove 2 old interfering variables, probably missed from [15299]	Nicolas Thill	2009-04-22	1	-2/+0
*	move pkg config stuff to per-target exports to prevent interference with host...	Felix Fietkau	2009-04-20	1	-3/+0
*	replace a few unnecessary $(shell) calls	Felix Fietkau	2009-03-03	1	-1/+1
*	initialize the url field for packages	Felix Fietkau	2009-02-23	1	-0/+1
*	eliminate redundancy by creating the quilt_used stampfile in the right place	Felix Fietkau	2009-02-22	1	-1/+0
*	add support for build-only packages which do not appear in menuconfig	Felix Fietkau	2009-01-13	1	-0/+1
*	make config.{guess,sub} writable before attempting to overwrite them (many pa...	Felix Fietkau	2009-01-06	1	-1/+1
*	add default Build/Install template, which is activated by setting PKG_INSTALL=1	Felix Fietkau	2008-09-03	1	-0/+11
*	replace config.guess and config.sub properly, even if they are in a subdirectory	Felix Fietkau	2008-08-05	1	-1/+4
*	export PKG_CONFIG_PATH and PKG_CONFIG_LIBDIR by default (#3376)	Felix Fietkau	2008-07-31	1	-2/+5
*	add a configurable prefix for ./configure	Felix Fietkau	2007-12-27	1	-8/+9
*	add STAGING_DIR_HOST to PKG_CONFIG_PATH	Felix Fietkau	2007-12-23	1	-1/+1
*	DESCRIPTION:= is obselete, so complain if it is used and use TITLE if no desc...	John Crispin	2007-10-14	1	-1/+0
*	move a stampfile to make it easier to override the patch template	Felix Fietkau	2007-09-29	1	-0/+1
*	fix typo (thanks to jonasg[1] on irc)	Nicolas Thill	2007-09-05	1	-1/+1
*	move TARGET_* flags from ./include/package-default.mk to ./rules.mk, remove E...	Nicolas Thill	2007-09-03	1	-9/+4
*	dynamically enable/disable kernel config options for kmod packages based on b...	Felix Fietkau	2007-07-18	1	-0/+1
*	use newer config.guess and config.sub for packages then the shipped ones	Imre Kaloz	2007-06-08	1	-0/+1
*	Add quilt integration for packages	Felix Fietkau	2007-06-03	1	-3/+2
*	split CONFIGURE_PATH into CONFIGURE_PATH and CONFIGURE_CMD for better handlin...	Felix Fietkau	2007-03-24	1	-3/+4
*	fix CONFIGURE_PATH and add MAKE_PATH	Felix Fietkau	2007-03-24	1	-2/+4
*	use recursive variable expansion for CONFIGURE_*, MAKE_* variables in the pac...	Felix Fietkau	2007-03-24	1	-7/+7
*	split package.mk and clean up build system code (based on patch by mbm), make...	Felix Fietkau	2007-03-15	1	-0/+106

generated by cgit v1.2.3 (git 2.25.1) at 2025-01-27 02:00:35 +0000

--  Iir to ortho translator.
--  Copyright (C) 2002 - 2014 Tristan Gingold
--
--  GHDL is free software; you can redistribute it and/or modify it under
--  the terms of the GNU General Public License as published by the Free
--  Software Foundation; either version 2, or (at your option) any later
--  version.
--
--  GHDL is distributed in the hope that it will be useful, but WITHOUT ANY
--  WARRANTY; without even the implied warranty of MERCHANTABILITY or
--  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
--  for more details.
--
--  You should have received a copy of the GNU General Public License
--  along with GCC; see the file COPYING.  If not, write to the Free
--  Software Foundation, 59 Temple Place - Suite 330, Boston, MA
--  02111-1307, USA.

with Name_Table;
with Std_Names;
with Std_Package; use Std_Package;
with Errorout; use Errorout;
with Sem_Inst;
with Nodes_Meta;
with Iirs_Utils; use Iirs_Utils;
with Trans.Chap3;
with Trans.Chap4;
with Trans.Chap5;
with Trans.Chap6;
with Trans.Chap8;
with Trans.Rtis;
with Trans_Decls; use Trans_Decls;
with Translation; use Translation;

package body Trans.Chap2 is
   use Trans.Subprgs;
   use Trans.Helpers;

   procedure Elab_Package (Spec : Iir_Package_Declaration);

   type Name_String_Xlat_Array is array (Name_Id range <>) of
     String (1 .. 4);
   Operator_String_Xlat : constant
     Name_String_Xlat_Array (Std_Names.Name_Id_Operators) :=
     (Std_Names.Name_Op_Equality => "OPEq",
      Std_Names.Name_Op_Inequality => "OPNe",
      Std_Names.Name_Op_Less => "OPLt",
      Std_Names.Name_Op_Less_Equal => "OPLe",
      Std_Names.Name_Op_Greater => "OPGt",
      Std_Names.Name_Op_Greater_Equal => "OPGe",
      Std_Names.Name_Op_Plus => "OPPl",
      Std_Names.Name_Op_Minus => "OPMi",
      Std_Names.Name_Op_Mul => "OPMu",
      Std_Names.Name_Op_Div => "OPDi",
      Std_Names.Name_Op_Exp => "OPEx",
      Std_Names.Name_Op_Concatenation => "OPCc",
      Std_Names.Name_Op_Condition => "OPCd",
      Std_Names.Name_Op_Match_Equality => "OPQe",
      Std_Names.Name_Op_Match_Inequality => "OPQi",
      Std_Names.Name_Op_Match_Less => "OPQL",
      Std_Names.Name_Op_Match_Less_Equal => "OPQl",
      Std_Names.Name_Op_Match_Greater => "OPQG",
      Std_Names.Name_Op_Match_Greater_Equal => "OPQg");

   --  Set the identifier prefix with the subprogram identifier and
   --  overload number if any.
   procedure Push_Subprg_Identifier (Spec : Iir; Mark : out Id_Mark_Type)
   is
      Id : Name_Id;
   begin
      --  FIXME: name_shift_operators, name_logical_operators,
      --   name_word_operators, name_mod, name_rem
      Id := Get_Identifier (Spec);
      if Id in Std_Names.Name_Id_Operators then
         Push_Identifier_Prefix
           (Mark, Operator_String_Xlat (Id), Get_Overload_Number (Spec));
      else
         Push_Identifier_Prefix (Mark, Id, Get_Overload_Number (Spec));
      end if;
   end Push_Subprg_Identifier;

   procedure Translate_Subprogram_Interfaces (Spec : Iir)
   is
      Inter : Iir;
      Mark  : Id_Mark_Type;
   begin
      --  Set the identifier prefix with the subprogram identifier and
      --  overload number if any.
      Push_Subprg_Identifier (Spec, Mark);

      --  Translate interface types.
      Inter := Get_Interface_Declaration_Chain (Spec);
      while Inter /= Null_Iir loop
         Chap3.Translate_Object_Subtype (Inter);
         Inter := Get_Chain (Inter);
      end loop;
      Pop_Identifier_Prefix (Mark);
   end Translate_Subprogram_Interfaces;

   procedure Elab_Subprogram_Interfaces (Spec : Iir)
   is
      Inter : Iir;
   begin
      --  Translate interface types.
      Inter := Get_Interface_Declaration_Chain (Spec);
      while Inter /= Null_Iir loop
         Chap3.Elab_Object_Subtype (Get_Type (Inter));
         Inter := Get_Chain (Inter);
      end loop;
   end Elab_Subprogram_Interfaces;


   --  Return the type of a subprogram interface.
   --  Return O_Tnode_Null if the parameter is passed through the
   --  interface record.
   function Translate_Interface_Type (Inter : Iir) return O_Tnode
   is
      Mode  : Object_Kind_Type;
      Tinfo : constant Type_Info_Acc := Get_Info (Get_Type (Inter));
   begin
      case Get_Kind (Inter) is
         when Iir_Kind_Interface_Constant_Declaration
            | Iir_Kind_Interface_Variable_Declaration
            | Iir_Kind_Interface_File_Declaration =>
            Mode := Mode_Value;
         when Iir_Kind_Interface_Signal_Declaration =>
            Mode := Mode_Signal;
         when others =>
            Error_Kind ("translate_interface_type", Inter);
      end case;
      case Tinfo.Type_Mode is
         when Type_Mode_Unknown =>
            raise Internal_Error;
         when Type_Mode_By_Value =>
            return Tinfo.Ortho_Type (Mode);
         when Type_Mode_By_Copy
            | Type_Mode_By_Ref =>
            return Tinfo.Ortho_Ptr_Type (Mode);
      end case;
   end Translate_Interface_Type;

   procedure Translate_Subprogram_Declaration (Spec : Iir)
   is
      Info              : constant Subprg_Info_Acc := Get_Info (Spec);
      Is_Func           : constant Boolean :=
        Get_Kind (Spec) = Iir_Kind_Function_Declaration;
      Inter             : Iir;
      Inter_Type        : Iir;
      Arg_Info          : Ortho_Info_Acc;
      Tinfo             : Type_Info_Acc;
      Interface_List    : O_Inter_List;
      Has_Result_Record : Boolean;
      El_List           : O_Element_List;
      Mark              : Id_Mark_Type;
      Rtype             : Iir;
      Id                : O_Ident;
      Storage           : O_Storage;
      Foreign           : Foreign_Info_Type := Foreign_Bad;
   begin
      --  Set the identifier prefix with the subprogram identifier and
      --  overload number if any.
      Push_Subprg_Identifier (Spec, Mark);

      if Get_Foreign_Flag (Spec) then
         --  Special handling for foreign subprograms.
         Foreign := Translate_Foreign_Id (Spec);
         case Foreign.Kind is
            when Foreign_Unknown =>
               Id := Create_Identifier;
            when Foreign_Intrinsic =>
               Id := Create_Identifier;
            when Foreign_Vhpidirect =>
               Id := Get_Identifier
                 (Name_Table.Name_Buffer (Foreign.Subprg_First
                  .. Foreign.Subprg_Last));
         end case;
         Storage := O_Storage_External;
      else
         Id := Create_Identifier;
         Storage := Global_Storage;
      end if;

      if Is_Func then
         --  If the result of a function is a composite type for ortho,
         --  the result is allocated by the caller and an access to it is
         --  given to the function.
         Rtype := Get_Return_Type (Spec);
         Info.Use_Stack2 := False;
         Tinfo := Get_Info (Rtype);

         if Is_Composite (Tinfo) then
            Start_Procedure_Decl (Interface_List, Id, Storage);
            New_Interface_Decl
              (Interface_List, Info.Res_Interface,
               Get_Identifier ("RESULT"),
               Tinfo.Ortho_Ptr_Type (Mode_Value));
            --  Furthermore, if the result type is unconstrained, the
            --  function will allocate it on a secondary stack.
            if not Is_Fully_Constrained_Type (Rtype) then
               Info.Use_Stack2 := True;
            end if;
         else
            --  Normal function.
            Start_Function_Decl
              (Interface_List, Id, Storage, Tinfo.Ortho_Type (Mode_Value));
            Info.Res_Interface := O_Dnode_Null;
         end if;
      else
         --  Create info for each interface of the procedure.
         --  For parameters passed via copy and that needs a copy-out,
         --  gather them in a record.  An access to the record is then
         --  passed to the procedure.
         Has_Result_Record := False;
         Inter := Get_Interface_Declaration_Chain (Spec);
         while Inter /= Null_Iir loop
            Arg_Info := Add_Info (Inter, Kind_Interface);
            Inter_Type := Get_Type (Inter);
            Tinfo := Get_Info (Inter_Type);
            if Get_Kind (Inter) = Iir_Kind_Interface_Variable_Declaration
              and then Get_Mode (Inter) in Iir_Out_Modes
              and then Tinfo.Type_Mode not in Type_Mode_By_Ref
              and then Tinfo.Type_Mode /= Type_Mode_File
            then
               --  This interface is done via the result record.
               --  Note: file passed through variables are vhdl87 files,
               --        which are initialized at elaboration and thus
               --        behave like an IN parameter.
               if not Has_Result_Record then
                  --  Create the record.
                  Start_Record_Type (El_List);
                  Has_Result_Record := True;
               end if;
               --  Add a field to the record.
               New_Record_Field (El_List, Arg_Info.Interface_Field,
                                 Create_Identifier_Without_Prefix (Inter),
                                 Tinfo.Ortho_Type (Mode_Value));
            else
               Arg_Info.Interface_Field := O_Fnode_Null;
            end if;
            Inter := Get_Chain (Inter);
         end loop;
         if Has_Result_Record then
            --  Declare the record type and an access to the record.
            Finish_Record_Type (El_List, Info.Res_Record_Type);
            New_Type_Decl (Create_Identifier ("RESTYPE"),
                           Info.Res_Record_Type);
            Info.Res_Record_Ptr := New_Access_Type (Info.Res_Record_Type);
            New_Type_Decl (Create_Identifier ("RESPTR"),
                           Info.Res_Record_Ptr);
         else
            Info.Res_Interface := O_Dnode_Null;
         end if;

         Start_Procedure_Decl (Interface_List, Id, Storage);

         if Has_Result_Record then
            --  Add the record parameter.
            New_Interface_Decl (Interface_List, Info.Res_Interface,
                                Get_Identifier ("RESULT"),
                                Info.Res_Record_Ptr);
         end if;
      end if;

      --  Instance parameter if any.
      if not Get_Foreign_Flag (Spec) then
         Subprgs.Create_Subprg_Instance (Interface_List, Spec);
      end if;

      --  Translate interfaces.
      Inter := Get_Interface_Declaration_Chain (Spec);
      while Inter /= Null_Iir loop
         if Is_Func then
            --  Create the info.
            Arg_Info := Add_Info (Inter, Kind_Interface);
            Arg_Info.Interface_Field := O_Fnode_Null;
         else
            --  The info was already created (just above)
            Arg_Info := Get_Info (Inter);
         end if;

         if Arg_Info.Interface_Field = O_Fnode_Null then
            --  Not via the RESULT parameter.
            Arg_Info.Interface_Type := Translate_Interface_Type (Inter);
            New_Interface_Decl
              (Interface_List, Arg_Info.Interface_Node,
               Create_Identifier_Without_Prefix (Inter),
               Arg_Info.Interface_Type);
         end if;
         Inter := Get_Chain (Inter);
      end loop;
      Finish_Subprogram_Decl (Interface_List, Info.Ortho_Func);

      --  Call the hook for foreign subprograms.
      if Get_Foreign_Flag (Spec) and then Foreign_Hook /= null then
         Foreign_Hook.all (Spec, Foreign, Info.Ortho_Func);
      end if;

      Save_Local_Identifier (Info.Subprg_Local_Id);
      Pop_Identifier_Prefix (Mark);
   end Translate_Subprogram_Declaration;

   --  Return TRUE iff subprogram specification SPEC is translated in an
   --  ortho function.
   function Is_Subprogram_Ortho_Function (Spec : Iir) return Boolean
   is
   begin
      if Get_Kind (Spec) = Iir_Kind_Procedure_Declaration then
         return False;
      end if;
      if Get_Info (Spec).Res_Interface /= O_Dnode_Null then
         return False;
      end if;
      return True;
   end Is_Subprogram_Ortho_Function;

   --  Return TRUE iif SUBPRG_BODY declares explicitely or implicitely
   --  (or even implicitely by translation) a subprogram.
   function Has_Nested_Subprograms (Subprg_Body : Iir) return Boolean
   is
      Decl  : Iir;
      Atype : Iir;
   begin
      Decl := Get_Declaration_Chain (Subprg_Body);
      while Decl /= Null_Iir loop
         case Get_Kind (Decl) is
            when Iir_Kind_Function_Declaration
               | Iir_Kind_Procedure_Declaration =>
               return True;
            when Iir_Kind_Function_Body
               | Iir_Kind_Procedure_Body =>
               --  The declaration preceed the body.
               raise Internal_Error;
            when Iir_Kind_Type_Declaration
               | Iir_Kind_Anonymous_Type_Declaration =>
               Atype := Get_Type_Definition (Decl);
               case Iir_Kinds_Type_And_Subtype_Definition
                 (Get_Kind (Atype)) is
                  when Iir_Kinds_Scalar_Type_Definition =>
                     null;
                  when Iir_Kind_Access_Type_Definition
                     | Iir_Kind_Access_Subtype_Definition =>
                     null;
                  when Iir_Kind_File_Type_Definition =>
                     return True;
                  when Iir_Kind_Protected_Type_Declaration =>
                     raise Internal_Error;
                  when Iir_Kinds_Composite_Type_Definition =>
                     --  At least for "=".
                     return True;
                  when Iir_Kind_Incomplete_Type_Definition =>
                     null;
               end case;
            when others =>
               null;
         end case;
         Decl := Get_Chain (Decl);
      end loop;
      return False;
   end Has_Nested_Subprograms;

   procedure Translate_Subprogram_Body (Subprg : Iir)
   is
      Spec : constant Iir := Get_Subprogram_Specification (Subprg);
      Info : constant Ortho_Info_Acc := Get_Info (Spec);

      Old_Subprogram : Iir;
      Mark           : Id_Mark_Type;
      Final          : Boolean;
      Is_Ortho_Func  : Boolean;

      --  Set for a public method.  In this case, the lock must be acquired
      --  and retained.
      Is_Prot : Boolean := False;

      --  True if the body has local (nested) subprograms.
      Has_Nested : Boolean;

      Frame_Ptr_Type : O_Tnode;
      Upframe_Field  : O_Fnode;

      Frame     : O_Dnode;
      Frame_Ptr : O_Dnode;

      Has_Return : Boolean;

      Prev_Subprg_Instances : Subprgs.Subprg_Instance_Stack;
   begin
      --  Do not translate body for foreign subprograms.
      if Get_Foreign_Flag (Spec) then
         return;
      end if;

      --  Check if there are nested subprograms to unnest.  In that case,
      --  a frame record is created, which is less efficient than the
      --  use of local variables.
      if Flag_Unnest_Subprograms then
         Has_Nested := Has_Nested_Subprograms (Subprg);
      else
         Has_Nested := False;
      end if;

      --  Set the identifier prefix with the subprogram identifier and
      --  overload number if any.
      Push_Subprg_Identifier (Spec, Mark);
      Restore_Local_Identifier (Info.Subprg_Local_Id);

      if Has_Nested then
         --  Unnest subprograms.
         --  Create an instance for the local declarations.
         Push_Instance_Factory (Info.Subprg_Frame_Scope'Access);
         Add_Subprg_Instance_Field (Upframe_Field);

         if Info.Res_Record_Ptr /= O_Tnode_Null then
            Info.Res_Record_Var :=
              Create_Var (Create_Var_Identifier ("RESULT"),
                          Info.Res_Record_Ptr);
         end if;

         --  Create fields for parameters.
         --  FIXME: do it only if they are referenced in nested
         --  subprograms.
         declare
            Inter      : Iir;
            Inter_Info : Inter_Info_Acc;
         begin
            Inter := Get_Interface_Declaration_Chain (Spec);
            while Inter /= Null_Iir loop
               Inter_Info := Get_Info (Inter);
               if Inter_Info.Interface_Node /= O_Dnode_Null then
                  Inter_Info.Interface_Field :=
                    Add_Instance_Factory_Field
                      (Create_Identifier_Without_Prefix (Inter),
                       Inter_Info.Interface_Type);
               end if;
               Inter := Get_Chain (Inter);
            end loop;
         end;

         Chap4.Translate_Declaration_Chain (Subprg);
         Pop_Instance_Factory (Info.Subprg_Frame_Scope'Access);

         New_Type_Decl (Create_Identifier ("_FRAMETYPE"),
                        Get_Scope_Type (Info.Subprg_Frame_Scope));
         Declare_Scope_Acc
           (Info.Subprg_Frame_Scope,
            Create_Identifier ("_FRAMEPTR"), Frame_Ptr_Type);

         Rtis.Generate_Subprogram_Body (Subprg);

         --  Local frame
         Subprgs.Push_Subprg_Instance
           (Info.Subprg_Frame_Scope'Access, Frame_Ptr_Type,
            Wki_Upframe, Prev_Subprg_Instances);
         --  Link to previous frame
         Subprgs.Start_Prev_Subprg_Instance_Use_Via_Field
           (Prev_Subprg_Instances, Upframe_Field);

         Chap4.Translate_Declaration_Chain_Subprograms (Subprg);

         --  Link to previous frame
         Subprgs.Finish_Prev_Subprg_Instance_Use_Via_Field
           (Prev_Subprg_Instances, Upframe_Field);
         --  Local frame
         Subprgs.Pop_Subprg_Instance (Wki_Upframe, Prev_Subprg_Instances);
      end if;

      --  Create the body

      Start_Subprogram_Body (Info.Ortho_Func);

      Start_Subprg_Instance_Use (Spec);

      --  Variables will be created on the stack.
      Push_Local_Factory;

      --  Code has access to local (and outer) variables.
      --  FIXME: this is not necessary if Has_Nested is set
      Subprgs.Clear_Subprg_Instance (Prev_Subprg_Instances);

      --  There is a local scope for temporaries.
      Open_Local_Temp;

      if not Has_Nested then
         Chap4.Translate_Declaration_Chain (Subprg);
         Rtis.Generate_Subprogram_Body (Subprg);
         Chap4.Translate_Declaration_Chain_Subprograms (Subprg);
      else
         New_Var_Decl (Frame, Wki_Frame, O_Storage_Local,
                       Get_Scope_Type (Info.Subprg_Frame_Scope));

         New_Var_Decl (Frame_Ptr, Get_Identifier ("FRAMEPTR"),
                       O_Storage_Local, Frame_Ptr_Type);
         New_Assign_Stmt (New_Obj (Frame_Ptr),
                          New_Address (New_Obj (Frame), Frame_Ptr_Type));

         --  FIXME: use direct reference (ie Frame instead of Frame_Ptr)
         Set_Scope_Via_Param_Ptr (Info.Subprg_Frame_Scope, Frame_Ptr);

         --  Set UPFRAME.
         Subprgs.Set_Subprg_Instance_Field
           (Frame_Ptr, Upframe_Field, Info.Subprg_Instance);

         if Info.Res_Record_Type /= O_Tnode_Null then
            --  Initialize the RESULT field
            New_Assign_Stmt (Get_Var (Info.Res_Record_Var),
                             New_Obj_Value (Info.Res_Interface));
            --  Do not reference the RESULT field in the subprogram body,
            --  directly reference the RESULT parameter.
            --  FIXME: has a flag (see below for parameters).
            Info.Res_Record_Var := Null_Var;
         end if;

         --  Copy parameters to FRAME.
         declare
            Inter      : Iir;
            Inter_Info : Inter_Info_Acc;
         begin
            Inter := Get_Interface_Declaration_Chain (Spec);
            while Inter /= Null_Iir loop
               Inter_Info := Get_Info (Inter);
               if Inter_Info.Interface_Node /= O_Dnode_Null then
                  New_Assign_Stmt
                    (New_Selected_Element (New_Obj (Frame),
                     Inter_Info.Interface_Field),
                     New_Obj_Value (Inter_Info.Interface_Node));

                  --  Forget the reference to the field in FRAME, so that
                  --  this subprogram will directly reference the parameter
                  --  (and not its copy in the FRAME).
                  Inter_Info.Interface_Field := O_Fnode_Null;
               end if;
               Inter := Get_Chain (Inter);
            end loop;
         end;
      end if;

      --  Init out parameters passed by value/copy.
      declare
         Inter      : Iir;
         Inter_Type : Iir;
         Type_Info  : Type_Info_Acc;
      begin
         Inter := Get_Interface_Declaration_Chain (Spec);
         while Inter /= Null_Iir loop
            if Get_Kind (Inter) = Iir_Kind_Interface_Variable_Declaration
              and then Get_Mode (Inter) = Iir_Out_Mode
            then
               Inter_Type := Get_Type (Inter);
               Type_Info := Get_Info (Inter_Type);
               if (Type_Info.Type_Mode in Type_Mode_By_Value
                   or Type_Info.Type_Mode in Type_Mode_By_Copy)
                 and then Type_Info.Type_Mode /= Type_Mode_File
               then
                  Chap4.Init_Object
                    (Chap6.Translate_Name (Inter), Inter_Type);
               end if;
            end if;
            Inter := Get_Chain (Inter);
         end loop;
      end;

      Chap4.Elab_Declaration_Chain (Subprg, Final);

      --  If finalization is required, create a dummy loop around the
      --  body and convert returns into exit out of this loop.
      --  If the subprogram is a function, also create a variable for the
      --  result.
      Is_Prot := Is_Subprogram_Method (Spec);
      if Final or Is_Prot then
         if Is_Prot then
            --  Lock the object.
            Chap3.Call_Ghdl_Protected_Procedure (Get_Method_Type (Spec),
                                                 Ghdl_Protected_Enter);
         end if;
         Is_Ortho_Func := Is_Subprogram_Ortho_Function (Spec);
         if Is_Ortho_Func then
            New_Var_Decl
              (Info.Subprg_Result, Get_Identifier ("RESULT"),
               O_Storage_Local,
               Get_Ortho_Type (Get_Return_Type (Spec), Mode_Value));
         end if;
         Start_Loop_Stmt (Info.Subprg_Exit);
      end if;

      Old_Subprogram := Current_Subprogram;
      Current_Subprogram := Spec;
      Has_Return := Chap8.Translate_Statements_Chain_Has_Return
        (Get_Sequential_Statement_Chain (Subprg));
      Current_Subprogram := Old_Subprogram;

      if Final or Is_Prot then
         --  Create a barrier to catch missing return statement.
         if Get_Kind (Spec) = Iir_Kind_Procedure_Declaration then
            New_Exit_Stmt (Info.Subprg_Exit);
         else
            if not Has_Return then
               --  Missing return
               Chap6.Gen_Program_Error
                 (Subprg, Chap6.Prg_Err_Missing_Return);
            end if;
         end if;
         Finish_Loop_Stmt (Info.Subprg_Exit);
         Chap4.Final_Declaration_Chain (Subprg, False);

         if Is_Prot then
            --  Unlock the object.
            Chap3.Call_Ghdl_Protected_Procedure (Get_Method_Type (Spec),
                                                 Ghdl_Protected_Leave);
         end if;
         if Is_Ortho_Func then
            New_Return_Stmt (New_Obj_Value (Info.Subprg_Result));
         end if;
      else
         if Get_Kind (Spec) = Iir_Kind_Function_Declaration
           and then not Has_Return
         then
            --  Missing return
            Chap6.Gen_Program_Error
              (Subprg, Chap6.Prg_Err_Missing_Return);
         end if;
      end if;

      if Has_Nested then
         Clear_Scope (Info.Subprg_Frame_Scope);
      end if;

      Subprgs.Pop_Subprg_Instance (O_Ident_Nul, Prev_Subprg_Instances);
      Close_Local_Temp;
      Pop_Local_Factory;

      Finish_Subprg_Instance_Use (Spec);

      Finish_Subprogram_Body;

      Pop_Identifier_Prefix (Mark);
   end Translate_Subprogram_Body;

   procedure Translate_Package_Declaration (Decl : Iir_Package_Declaration)
   is
      Header               : constant Iir := Get_Package_Header (Decl);
      Info                 : Ortho_Info_Acc;
      Interface_List       : O_Inter_List;
      Prev_Subprg_Instance : Subprgs.Subprg_Instance_Stack;
   begin
      Info := Add_Info (Decl, Kind_Package);

      --  Translate declarations.
      if Is_Uninstantiated_Package (Decl) then
         --  Create an instance for the spec.
         Push_Instance_Factory (Info.Package_Spec_Scope'Access);
         Chap4.Translate_Generic_Chain (Header);
         Chap4.Translate_Declaration_Chain (Decl);
         Info.Package_Elab_Var := Create_Var
           (Create_Var_Identifier ("ELABORATED"), Ghdl_Bool_Type);
         Pop_Instance_Factory (Info.Package_Spec_Scope'Access);

         --  Name the spec instance and create a pointer.
         New_Type_Decl (Create_Identifier ("SPECINSTTYPE"),
                        Get_Scope_Type (Info.Package_Spec_Scope));
         Declare_Scope_Acc (Info.Package_Spec_Scope,
                            Create_Identifier ("SPECINSTPTR"),
                            Info.Package_Spec_Ptr_Type);

         --  Create an instance and its pointer for the body.
         Chap2.Declare_Inst_Type_And_Ptr
           (Info.Package_Body_Scope'Access, Info.Package_Body_Ptr_Type);

         --  Each subprogram has a body instance argument.
         Subprgs.Push_Subprg_Instance
           (Info.Package_Body_Scope'Access, Info.Package_Body_Ptr_Type,
            Wki_Instance, Prev_Subprg_Instance);
      else
         Chap4.Translate_Declaration_Chain (Decl);
         Info.Package_Elab_Var := Create_Var
           (Create_Var_Identifier ("ELABORATED"), Ghdl_Bool_Type);
      end if;

      --  Translate subprograms declarations.
      Chap4.Translate_Declaration_Chain_Subprograms (Decl);

      --  Declare elaborator for the body.
      Start_Procedure_Decl
        (Interface_List, Create_Identifier ("ELAB_BODY"), Global_Storage);
      Subprgs.Add_Subprg_Instance_Interfaces
        (Interface_List, Info.Package_Elab_Body_Instance);
      Finish_Subprogram_Decl
        (Interface_List, Info.Package_Elab_Body_Subprg);

      if Is_Uninstantiated_Package (Decl) then
         Subprgs.Pop_Subprg_Instance (Wki_Instance, Prev_Subprg_Instance);

         --  The spec elaborator has a spec instance argument.
         Subprgs.Push_Subprg_Instance
           (Info.Package_Spec_Scope'Access, Info.Package_Spec_Ptr_Type,
            Wki_Instance, Prev_Subprg_Instance);
      end if;

      Start_Procedure_Decl
        (Interface_List, Create_Identifier ("ELAB_SPEC"), Global_Storage);
      Subprgs.Add_Subprg_Instance_Interfaces
        (Interface_List, Info.Package_Elab_Spec_Instance);
      Finish_Subprogram_Decl
        (Interface_List, Info.Package_Elab_Spec_Subprg);

      if Flag_Rti then
         --  Generate RTI.
         Rtis.Generate_Unit (Decl);
      end if;

      if Global_Storage = O_Storage_Public then
         --  Create elaboration procedure for the spec
         Elab_Package (Decl);
      end if;

      if Is_Uninstantiated_Package (Decl) then
         Subprgs.Pop_Subprg_Instance (Wki_Instance, Prev_Subprg_Instance);
      end if;
      Save_Local_Identifier (Info.Package_Local_Id);
   end Translate_Package_Declaration;

   procedure Translate_Package_Body (Decl : Iir_Package_Body)
   is
      Spec : constant Iir_Package_Declaration := Get_Package (Decl);
      Info : constant Ortho_Info_Acc := Get_Info (Spec);
      Prev_Subprg_Instance : Subprgs.Subprg_Instance_Stack;
   begin
      --  Translate declarations.
      if Is_Uninstantiated_Package (Spec) then
         Push_Instance_Factory (Info.Package_Body_Scope'Access);
         Info.Package_Spec_Field := Add_Instance_Factory_Field
           (Get_Identifier ("SPEC"),
            Get_Scope_Type (Info.Package_Spec_Scope));

         Chap4.Translate_Declaration_Chain (Decl);

         Pop_Instance_Factory (Info.Package_Body_Scope'Access);

         if Global_Storage = O_Storage_External then
            return;
         end if;
      else
         --  May be called during elaboration to generate RTI.
         if Global_Storage = O_Storage_External then
            return;
         end if;

         Restore_Local_Identifier (Get_Info (Spec).Package_Local_Id);

         Chap4.Translate_Declaration_Chain (Decl);
      end if;

      if Flag_Rti then
         Rtis.Generate_Unit (Decl);
      end if;

      if Is_Uninstantiated_Package (Spec) then
         Subprgs.Push_Subprg_Instance
           (Info.Package_Body_Scope'Access, Info.Package_Body_Ptr_Type,
            Wki_Instance, Prev_Subprg_Instance);
         Set_Scope_Via_Field (Info.Package_Spec_Scope,
                              Info.Package_Spec_Field,
                              Info.Package_Body_Scope'Access);
      end if;

      Chap4.Translate_Declaration_Chain_Subprograms (Decl);

      if Is_Uninstantiated_Package (Spec) then
         Clear_Scope (Info.Package_Spec_Scope);
         Subprgs.Pop_Subprg_Instance (Wki_Instance, Prev_Subprg_Instance);
      end if;

      Elab_Package_Body (Spec, Decl);
   end Translate_Package_Body;

   procedure Elab_Package (Spec : Iir_Package_Declaration)
   is
      Info   : constant Ortho_Info_Acc := Get_Info (Spec);
      Final  : Boolean;
      Constr : O_Assoc_List;