fpc/rtl/amiga/powerpc/execd.inc

{
    This file is part of the Free Pascal run time library.
    Copyright (c) 2016 by Free Pascal development team

    exec.library functions for Amiga OS 4.x

    See the file COPYING.FPC, included in this distribution,
    for details about the copyright.

    This program 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.

 **********************************************************************}

{$PACKRECORDS 2}

{$i utild1.inc}

// TODO: ExtMem.h - still missing ExtMemIFace discuss how to (open all possible interfaces)
//                  or make an other unit?
//       Initializers.h - Macros needed?

type
  STRPTR   = PChar;
  PSTRPTR  = PPChar;
  ULONG    = Longword;
  LONG     = LongInt;
  APTR     = Pointer;
  //BPTR     = LongInt; // Long word (BCPL) pointer
  //BSTR     = LongInt; // Long word pointer to BCPL string
  BOOL     = SmallInt;
  UWORD    = Word;
  WORDBITS = Word;
  LONGBITS = LongWord;
  PLONGBITS = ^LONGBITS;
  UBYTE    = Byte;
  PULONG   = ^LongWord;
  PAPTR    = ^APTR;
  PLONG    = ^LONG;

type
// List Node Structure.  Each member in a list starts with a Node
  PNode = ^TNode;
  TNode =  record
    ln_Succ,           // Pointer to next (successor)
    ln_Pred: PNode;    // Pointer to previous (predecessor)
    ln_Type: Byte;
    ln_Pri: Shortint;  // Priority, for sorting
    ln_Name: STRPTR;   // ID string, null terminated
  end;  // Note: smallint aligned

// minimal node -- no type checking possible
  PMinNode = ^TMinNode;
  TMinNode =  record
    mln_Succ,
    mln_Pred: PMinNode;
  end;

// Note: Newly initialized IORequests, and software interrupt structures
// used with Cause(), should have type NT_UNKNOWN.  The OS will assign a type
// when they are first used.
// ----- Node Types for LN_TYPE -----
const
  NT_UNKNOWN      =  0;
  NT_TASK         =  1;  // Exec task
  NT_INTERRUPT    =  2;
  NT_DEVICE       =  3;
  NT_MSGPORT      =  4;
  NT_MESSAGE      =  5;  // Indicates message currently pending
  NT_FREEMSG      =  6;
  NT_REPLYMSG     =  7;  // Message has been replied
  NT_RESOURCE     =  8;
  NT_LIBRARY      =  9;
  NT_MEMORY       = 10;
  NT_SOFTINT      = 11;  // Internal flag used by SoftInits
  NT_FONT         = 12;
  NT_PROCESS      = 13;  // AmigaDOS Process
  NT_SEMAPHORE    = 14;
  NT_SIGNALSEM    = 15;  // signal semaphores
  NT_BOOTNODE     = 16;
  NT_KICKMEM      = 17;
  NT_GRAPHICS     = 18;
  NT_DEATHMESSAGE = 19;

  // New additions in V50
  NT_EXTINTERRUPT =  20;  // Native interrupt
  NT_EXTSOFTINT   =  21;  // Native soft interrupt
  NT_VMAREA       =  22;  // Internal use only
  NT_VMAREA_PROXY =  23;  // Internal use only
  NT_CLASS        =  24;  // Class
  NT_INTERFACE    =  25;  // Interface

  // New additions in V51
  NT_KMEMCACHE    =  26;  // Internal use only
  NT_RESERVED1    =  27;

  // New additions in V53
  NT_FILESYSTEM   =  28;  // For new style Vector-Port based Filesystems

  // New additions in V54
  NT_PAGE         =  40;

  NT_ELFHANDLE    =  41;
  NT_SOLIBHANDLE  =  42;

  NT_USER         = 254;  // User node types work down from here
  NT_EXTENDED     = 255;


// START consts and types from utility needed here

const
// differentiates user tags from control tags
 TAG_USER = $80000000;    // differentiates user tags from system tags
type
  Tag = LongWord;
  PTag = ^Tag;

  PTagItem = ^TTagItem;
  TTagItem = record
    ti_Tag: Tag;        // identifies the type of data
    ti_Data: LongWord;  // type-specific data
  end;
  PPTagItem = ^PTagItem;

  PHook = ^THook;
  THook = record
    h_MinNode: TMinNode;
    h_Entry: Pointer;    // assembler entry point
    h_SubEntry: Pointer; // often HLL entry point
    h_Data: Pointer;     // owner specific
  end;

// END consts and types from utility needed here


const
  {There is a problem with boolean
  vaules in taglists, just use this
  for now instead}
  LTrue : LongInt = 1;
  LFalse: LongInt = 0;

{
    This file defines Exec system lists, which are used to link
    various things.  Exec provides several routines to handle list
    processing (defined at the bottom of this file), so you can
    use these routines to save yourself the trouble of writing a list
    package.
}


type
// Full featured list header.
  PList = ^TList;
  TList =  record
    lh_Head: PNode;
    lh_Tail: PNode;
    lh_TailPred: PNode;
    lh_Type: Byte;
    l_pad: Byte;
  end; // word aligned

// Minimal List Header - no type checking
  PMinList = ^TMinList;
  TMinList =  record
    mlh_Head: PMinNode;
    mlh_Tail: PMinNode;
    mlh_TailPred: PMinNode;
  end; // LongWord aligned


{ ********************************************************************
*
*  Format of the alert error number:
*
*    +-+-------------+----------------+--------------------------------+
*    |D|  SubSysId   |  General Error |    SubSystem Specific Error    |
*    +-+-------------+----------------+--------------------------------+
*     1    7 bits          8 bits                  16 bits
*
*                    D:  Deadend alert
*             SubSysId:  indicates ROM subsystem number.
*        General Error:  roughly indicates what the error was
*       Specific Error:  indicates more detail
*********************************************************************}

const
{*********************************************************************
*
*  Hardware/CPU specific alerts:  They may show without the 8 at the
*  front of the number.  These are CPU/68000 specific.  See 68$0
*  programmer's manuals for more details.
*
*********************************************************************}
  ACPU_BusErr     = $80000002;      { Hardware bus fault/access error }
  ACPU_AddressErr = $80000003;      { Illegal address access (ie: odd) }
  ACPU_InstErr    = $80000004;      { Illegal instruction }
  ACPU_DivZero    = $80000005;      { Divide by zero }
  ACPU_CHK        = $80000006;      { Check instruction error }
  ACPU_TRAPV      = $80000007;      { TrapV instruction error }
  ACPU_PrivErr    = $80000008;      { Privilege violation error }
  ACPU_Trace      = $80000009;      { Trace error }
  ACPU_LineA      = $8000000A;      { Line 1010 Emulator error }
  ACPU_LineF      = $8000000B;      { Line 1111 Emulator error }
  ACPU_Format     = $8000000E;      { Stack frame format error }
  ACPU_Spurious   = $80000018;      { Spurious interrupt error }
  ACPU_AutoVec1   = $80000019;      { AutoVector Level 1 interrupt error }
  ACPU_AutoVec2   = $8000001A;      { AutoVector Level 2 interrupt error }
  ACPU_AutoVec3   = $8000001B;      { AutoVector Level 3 interrupt error }
  ACPU_AutoVec4   = $8000001C;      { AutoVector Level 4 interrupt error }
  ACPU_AutoVec5   = $8000001D;      { AutoVector Level 5 interrupt error }
  ACPU_AutoVec6   = $8000001E;      { AutoVector Level 6 interrupt error }
  ACPU_AutoVec7   = $8000001F;      { AutoVector Level 7 interrupt error }


{ ********************************************************************
*
*  General Alerts
*
*  For example: timer.device cannot open math.library would be $05038015
*
*       Alert(AN_TimerDev|AG_OpenLib|AO_MathLib);
*
********************************************************************}


const

// ------ alert types
  AT_Deadend    = $80000000;
  AT_Recovery   = $00000000;

// ------ general purpose alert codes
  AG_NoMemory   = $00010000;
  AG_MakeLib    = $00020000;
  AG_OpenLib    = $00030000;
  AG_Opendev    = $00040000;
  AG_OpenRes    = $00050000;
  AG_IOError    = $00060000;
  AG_NoSignal   = $00070000;
  AG_BadParm    = $00080000;
  AG_CloseLib   = $00090000; // usually too many closes
  AG_CloseDev   = $000A0000; // or a mismatched close
  AG_ProcCreate = $000B0000; // Process creation failed
  AG_Obsolete   = $000C0000; // Obsolete feature used */

// ------ alert objects:
  AO_ExecLib      = $00008001;
  AO_GraphicsLib  = $00008002;
  AO_LayersLib    = $00008003;
  AO_Intuition    = $00008004;
  AO_MathLib      = $00008005;
  AO_DOSLib       = $00008007;
  AO_RAMLib       = $00008008;
  AO_IconLib      = $00008009;
  AO_ExpansionLib = $0000800A;
  AO_DiskfontLib  = $0000800B;
  AO_UtilityLib   = $0000800C;
  AO_KeyMapLib    = $0000800D;
  AO_NewlibLib    = $0000800E;

  AO_AudioDev     = $00008010;
  AO_ConsoleDev   = $00008011;
  AO_GamePortDev  = $00008012;
  AO_KeyboardDev  = $00008013;
  AO_TrackDiskDev = $00008014;
  AO_TimerDev     = $00008015;

  AO_CIARsrc    = $00008020;
  AO_DiskRsrc   = $00008021;
  AO_MiscRsrc   = $00008022;

  AO_BootStrap  = $00008030;
  AO_Workbench  = $00008031;
  AO_DiskCopy   = $00008032;
  AO_GadTools   = $00008033;
  AO_Unknown    = $00008035;



{ ********************************************************************
*
*   Specific Alerts:
*
********************************************************************}

// ------ exec.library

  AN_ExecLib     = $01000000;
  AN_ExcptVect   = $01000001; //  68000 exception vector checksum (obs.)
  AN_BaseChkSum  = $01000002; //  Execbase checksum (obs.)
  AN_LibChkSum   = $01000003; // Library checksum failure
  AN_IFaceChkSum = $01000004; // Interface checksum failure

  AN_MemCorrupt = $81000005; //  Corrupt memory list detected in FreeMem
  AN_IntrMem    = $81000006; //  No memory for interrupt servers
  AN_InitAPtr   = $01000007; //  InitStruct() of an APTR source (obs.)
  AN_SemCorrupt = $01000008; //  A semaphore is in an illegal state at ReleaseSempahore()

  AN_FreeTwice    = $01000009; //  Freeing memory already freed
  AN_BogusExcpt   = $8100000A; //  illegal 68k exception taken (obs.)
  AN_IOUsedTwice  = $0100000B; //  Attempt to reuse active IORequest
  AN_MemoryInsane = $0100000C; //  Sanity check on memory list failed during AvailMem(MEMF_LARGEST)
  AN_IOAfterClose = $0100000D; //  IO attempted on closed IORequest
  AN_StackProbe   = $0100000E; //  Stack appears to extend out of range
  AN_BadFreeAddr  = $0100000F; //  Memory header not located. [ Usually an invalid address passed to FreeMem() ]
  AN_BadSemaphore = $01000010; // An attempt was made to use the old message semaphores.
  AN_BadMemory    = $01000011; // A bad memory request was made (Realloc on non-allocated memory)
  AN_BadHook      = $01000012; // An uninitialized hook was called
// ------ graphics.library
  AN_GraphicsLib  = $02000000;
  AN_GfxNoMem     = $82010000;  //  graphics out of memory
  AN_GfxNoMemMspc = $82010001;  //  MonitorSpec alloc, no memory
  AN_LongFrame    = $82010006;  //  long frame, no memory
  AN_ShortFrame   = $82010007;  //  short frame, no memory
  AN_TextTmpRas   = $02010009;  //  text, no memory for TmpRas
  AN_BltBitMap    = $8201000A;  //  BltBitMap, no memory
  AN_RegionMemory = $8201000B;  //  regions, memory not available
  AN_MakeVPort    = $82010030;  //  MakeVPort, no memory
  AN_GfxNewError  = $0200000C;
  AN_GfxFreeError = $0200000D;

  AN_GfxNoLCM     = $82011234;  //  emergency memory not available

  AN_ObsoleteFont = $02000401;  //  unsupported font description used

// ------ layers.library

  AN_LayersLib    = $03000000;
  AN_LayersNoMem  = $83010000;  //  layers out of memory

// ------ intuition.library
  AN_Intuition    = $04000000;
  AN_GadgetType   = $84000001;  //  unknown gadget type
  AN_BadGadget    = $04000001;  //  Recovery form of AN_GadgetType
  AN_CreatePort   = $84010002;  //  create port, no memory
  AN_ItemAlloc    = $04010003;  //  item plane alloc, no memory
  AN_SubAlloc     = $04010004;  //  sub alloc, no memory
  AN_PlaneAlloc   = $84010005;  //  plane alloc, no memory
  AN_ItemBoxTop   = $84000006;  //  item box top < RelZero
  AN_OpenScreen   = $84010007;  //  open screen, no memory
  AN_OpenScrnRast = $84010008;  //  open screen, raster alloc, no memory
  AN_SysScrnType  = $84000009;  //  open sys screen, unknown type
  AN_AddSWGadget  = $8401000A;  //  add SW gadgets, no memory
  AN_OpenWindow   = $8401000B;  //  open window, no memory
  AN_BadState     = $8400000C;  //  Bad State Return entering Intuition
  AN_BadMessage   = $8400000D;  //  Bad Message received by IDCMP
  AN_WeirdEcho    = $8400000E;  //  Weird echo causing incomprehension
  AN_NoConsole    = $8400000F;  //  couldn't open the Console Device
  AN_NoISem       = $04000010;  // Intuition skipped obtaining a sem
  AN_ISemOrder    = $04000011;  // Intuition obtained a sem in bad order

// ------ math.library
  AN_MathLib      = $05000000;

// ------ dos.library
  AN_DOSLib       = $07000000;
  AN_StartMem     = $07010001; //  no memory at startup
  AN_endTask      = $07000002; //  endTask didn't
  AN_QPktFail     = $07000003; //  Qpkt failure
  AN_AsyncPkt     = $07000004; //  Unexpected packet received
  AN_FreeVec      = $07000005; //  Freevec failed
  AN_DiskBlkSeq   = $07000006; //  Disk block sequence error
  AN_BitMap       = $07000007; //  Bitmap corrupt
  AN_KeyFree      = $07000008; //  Key already free
  AN_BadChkSum    = $07000009; //  Invalid checksum
  AN_DiskError    = $0700000A; //  Disk Error
  AN_KeyRange     = $0700000B; //  Key out of range
  AN_BadOverlay   = $0700000C; //  Bad overlay
  AN_BadInitFunc  = $0700000D; //  Invalid init packet for cli/shell
  AN_FileReclosed = $0700000E; //  A filehandle was closed more than once
  AN_NoBootNode   = $0700000F; //  No bootnode found in eb_MountList

// ------ ramlib.library
  AN_RAMLib       = $08000000;
  AN_BadSegList = $08000001; // no overlays in library seglists

// ------ icon.library
  AN_IconLib = $09000000;

// ------ expansion.library
  AN_ExpansionLib     = $0A000000;
  AN_BadExpansionFree = $0A000001; // freeed free region

// ------ diskfont.library
  AN_DiskfontLib = $0B000000;

//------ newlib.library
  AN_NewlibLib  = $0E000000;

// ------ audio.device
  AN_AudioDev   = $10000000;

// ------ console.device
  AN_ConsoleDev = $11000000;
  AN_NoWindow   = $11000001; // Console can't open initial window

// ------ gameport.device
  AN_GamePortDev = $12000000;

// ------ keyboard.device
  AN_KeyboardDev        = $13000000;

// ------ trackdisk.device
  AN_TrackDiskDev = $14000000;
  AN_TDCalibSeek  = $14000001;  // calibrate: seek error
  AN_TDDelay      = $14000002;  // delay: error on timer wait

// ------ timer.device
  AN_TimerDev     = $15000000;
  AN_TMBadReq     = $15000001; // bad request
  AN_TMBadSupply  = $15000002; // power supply -- no 50/60Hz ticks

//------ cybppc.device
  AN_CybppcDev    = $16000000;
  AN_CybppcNoTerm = $16000001; // no termination
  AN_CybppcNoWide = $16000002; // no wide termination

// ------ cia.resource
  AN_CIARsrc      = $20000000;

// ------ disk.resource
  AN_DiskRsrc   = $21000000;
  AN_DRHasDisk  = $21000001; // get unit: already has disk
  AN_DRIntNoAct = $21000002; // interrupt: no active unit

// ------ misc.resource
  AN_MiscRsrc   = $22000000;

// ------ bootstrap
  AN_BootStrap  = $30000000;
  AN_BootError  = $30000001; // boot code returned an error

// ------ Workbench
  AN_Workbench          = $31000000;
  AN_NoFonts            = $B1000001;
  AN_WBBadStartupMsg1   = $31000001;
  AN_WBBadStartupMsg2   = $31000002;
  AN_WBBadIOMsg         = $31000003; // Hacker code?
  AN_WBReLayoutToolMenu = $B1010009; // GadTools broke?

// ------ DiskCopy
  AN_DiskCopy   = $32000000;

// ------ toolkit for Intuition
  AN_GadTools   = $33000000;

// ------ System utility library
  AN_UtilityLib = $34000000;

// ------ For use by any application that needs it
  AN_Unknown    = $35000000;


type
  PResident = ^TResident;
  TResident = record
    rt_MatchWord: Word;     // smallint to match on (ILLEGAL)
    rt_MatchTag: PResident; // pointer to the above
    rt_EndSkip: APTR;       // address to continue scan
    rt_Flags: Byte;         // various tag flags
    rt_Version: Byte;       // release version number
    rt_Type: Byte;          // type of module (NT_mumble)
    rt_Pri: Shortint;       // initialization priority
    rt_Name: STRPTR;        // pointer to node name
    rt_IdString: STRPTR;    // pointer to ident string
    rt_Init: APTR;          // pointer to init code
  end;

const
  RTC_MATCHWORD   = $4AFC; // The 68000 "ILLEGAL" instruction

// enResidentFlags
  RTF_AUTOINIT   = 1 shl 7; // rt_Init points to data structure
  RTF_NATIVE     = 1 shl 5; // rt_Init points to a native function (otherwise, 68k is assumed)
  RTF_AFTERDOS   = 1 shl 2;
  RTF_SINGLETASK = 1 shl 1;
  RTF_COLDSTART  = 1 shl 0;

type
// ****** MemChunk *****************************************************

  PMemChunk = ^TMemChunk;
  TMemChunk = record
    mc_Next: PMemChunk;  // pointer to next chunk
    mc_Bytes: LongWord;  // chunk byte size
  end;

// ****** MemHeader ****************************************************

  PMemHeader = ^TMemHeader;
  TMemHeader = record
    mh_Node: TNode;
    mh_Attributes: Word; // characteristics of this region
    mh_First: PMemChunk; // first free region
    mh_Lower: APTR;      // lower memory bound
    mh_Upper: APTR;      // upper memory bound + 1
    mh_Free: LongWord;   // total number of free bytes
  end;

// ****** MemEntry *****************************************************

  PMemEntry = ^TMemEntry;
  TMemEntry = record
    me_Un: record
      case LongInt of
         0: (meu_Reqs: LongWord);
         1: (meu_Addr: APTR);
      end;
    me_Length: LongWord;
  end;

// ****** MemList ******************************************************
// Note: sizeof(struct MemList) includes the size of the first MemEntry!
  PMemList = ^TMemList;
  TMemList = record
    ml_Node: TNode;
    ml_NumEntries: Word;             // number of entries in this struct
    ml_ME: array[0..0] of TMemEntry; // the first entry
  end;

// ----- Memory Requirement Types ---------------------------
// ----- See the AllocMem() documentation for details--------

const
  MEMF_ANY           = 0;        // Any type of memory will do
  MEMF_PUBLIC        = 1 shl  0;
  MEMF_CHIP          = 1 shl  1;
  MEMF_FAST          = 1 shl  2;
  MEMF_VIRTUAL       = 1 shl  3; // Memory that is mapped/paged
  MEMF_EXECUTABLE    = 1 shl  4; // Memory that contains executable code
  MEMF_LOCAL         = 1 shl  8; // Memory that does not go away at RESET
  MEMF_24BITDMA      = 1 shl  9; // DMAable memory within 24 bits of address
  MEMF_KICK          = 1 shl 10; // Memory that can be used for KickTags
  MEMF_PRIVATE       = 1 shl 11; // Memory that is only _visible_ to the  allocator task
  MEMF_SHARED        = 1 shl 12; // Memory that is visible and accessible  to all tasks

  MEMF_CLEAR         = 1 shl 16; // AllocMem: NL out area before return
  MEMF_LARGEST       = 1 shl 17; // AvailMem: return the largest chunk size
  MEMF_REVERSE       = 1 shl 18; // AllocMem: allocate from the top down
  MEMF_TOTAL         = 1 shl 19; // AvailMem: return total size of memory
  MEMF_HWALIGNED     = 1 shl 20; // AllocMem: Allocate aligned to hardware  page size
  MEMF_DELAYED       = 1 shl 21; // AllocMem: Delay physical memory mapping
  MEMF_CORE_RESIDENT = 1 shl 22; // Availmem: return only memory that is not paged out
  MEMF_NO_EXPUNGE    = 1 shl 31; // AllocMem: Do not cause expunge on failure

  MEM_BLOCKSIZE = 16;
  MEM_BLOCKMASK = MEM_BLOCKSIZE - 1;

type
// ***** MemHandlerData ************************************************
// Note:  This structure is *READ ONLY* and only EXEC can create it!
  PMemHandlerData = ^TMemHandlerData;
  TMemHandlerData = record
    memh_RequestSize: LongWord;  // Requested allocation size
    memh_RequestFlags: LongWord; // Requested allocation flags
    memh_Flags: LongWord;        // Flags (see below)
  end;

const
  MEMHF_RECYCLE  = 1 shl 0; // 0 = First time, 1 = recycle

// ***** Low Memory handler return values ******************************
  MEM_DID_NOTHING = 0;  // Nothing we could do...
  MEM_ALL_DONE    = -1; // We did all we could do
  MEM_TRY_AGAIN   = 1;  // We did some, try the allocation again

// ****** Memory attributes ********************************************
//enMemAttrs
  MEMATTRF_WRITETHROUGH     = 1 shl  0; // Stores in this area update cache  and memory
  MEMATTRF_CACHEINHIBIT     = 1 shl  1; // Caches are inhibited in this  area
  MEMATTRF_COHERENT         = 1 shl  2; // Coherency required, stores to  same region will be serialized
  MEMATTRF_GUARDED          = 1 shl  3; // Ensure in-order execute of memory accesses
  MEMATTRF_REFERENCED       = 1 shl  4; // Page containing memory location has been referenced (used)
  MEMATTRF_CHANGED          = 1 shl  5; // Page containing memory location has been changed

    // The following are mutually exclusive
  MEMATTRF_SUPER_RW         = 0 shl  6;
  MEMATTRF_SUPER_RW_USER_RO = 1 shl  6;
  MEMATTRF_SUPER_RW_USER_RW = 2 shl  6;
  MEMATTRF_SUPER_RO_USER_RO = 3 shl  6;
  MEMATTRF_RW_MASK          = 3 shl  6;

  MEMATTRF_EXECUTE          = 1 shl  9; // CPU can execute instructions from this memory

  MEMATTRF_NOT_MAPPED       = 1 shl 10; // Special flag: The memory is not mapped at all. This flag is only used as return value of GetMemoryAttr
  MEMATTRF_RESERVED1        = 1 shl 11; // Used by the system
  MEMATTRF_RESERVED2        = 1 shl 12; // _NEVER_ use these
  MEMATTRF_RESERVER3        = 1 shl 13;

// Short forms for common cases
  MEMATTRF_READ_WRITE = MEMATTRF_SUPER_RW_USER_RW;
  MEMATTRF_READ_ONLY  = MEMATTRF_SUPER_RO_USER_RO;

// ****** GetMemoryAttrs flags *****************************************
// enGetMemoryAttrsFlags
  GMAF_REPORT_CR = 1 shl 0;

// ****** AllocSysObject flags *****************************************
// enAllocSysObjectFlags
  ASOF_NOTRACK = 1 shl 1; // Used internally to indicate no tracking of object

// ****** Trackable ****************************************************
// Warning: Do NOT allocate one of those yourself!
type
  PTrackable = ^TTrackable;
  TTrackable = record
    Destructor_: THook;
    Object_: APTR;
    Flags: LongWord;
    HashChain: PTrackable;
  end; // Long word aligned

const
// enTrackableFlags
  TRACKF_COMPACT = 1 shl 0; // Trackable was allocated by "constructor"

// ****** DMA Scatter list *********************************************
type
  PDMAEntry = ^TDMAEntry;
  TDMAEntry = record
    PhysicalAddress: APTR; // Physically mapped address
    BlockLength: LongWord; // Length of the block in physical memory
  end;

// ****** Named memory scan message ************************************
  PSNMMessage = ^TSNMMessage;
  TSNMMessage = record
    Namespace: STRPTR;
    Name: STRPTR;
    Memory: APTR;
    Size: LongWord;
    Flags: LongWord;
  end;

const
  SNMF_NAMESPACES_ONLY = 1 shl 0;

type
  PInterrupt = ^TInterrupt;
  TInterrupt =  record
    is_Node: TNode;
    is_Data: APTR;       // Server data segment
    is_Code: TProcedure; // Server code entry
  end;

  PIntVector = ^TIntVector;
  TIntVector =  record   // For EXEC use ONLY!
    iv_Data: APTR;
    iv_Code: TProcedure;
    iv_Node: PNode;
  end;

  PSoftIntList = ^TSoftIntList;
  TSoftIntList =  record // For EXEC use ONLY!
    sh_List: TList;
    sh_Pad: Word;
  end;

  PExceptionContext = ^TExceptionContext;
  TExceptionContext = record
    Flags: LongWord;               // Flags, describing the context (READ-ONLY)
    Traptype: LongWord;            // Type of trap (READ-ONLY)
    msr: LongWord;                 // Machine state
    ip: LongWord;                  // Return instruction pointer
    gpr: array[0..31] of LongWord; // r0 - r31
    cr: LongWord;                  // Condition code register
    xer: LongWord;                 // Extended exception register
    ctr: LongWord;                 // Count register
    lr: LongWord;                  // Link register
    dsisr: LongWord;               // DSI status register. Only set when valid
    dar: LongWord;                 // Data address register. Only set when valid
    fpr: array[0..31] of double;   // Floating point registers
    fpscr: QWord;                  // Floating point control and status register
    // The following are only used on AltiVec
    vscr: array[0..15] of Byte;    // AltiVec vector status and control register
    vr: array[0..511] of Byte;     // AltiVec vector register storage
    vrsave: LongWord;              // AltiVec VRSAVE register
  end;

const
// Flags for ExceptionContext
// enECFlags
  ECF_FULL_GPRS = 1 shl 0; // Set if all register have been saved
                           // If this flag is not set; gpr[14] through
                           // gpr[31] are invalid
  ECF_FPU       = 1 shl 1; // Set if the FPU registers have been saved
  ECF_FULL_FPU  = 1 shl 2; // Set if all FPU registers have been saved
  ECF_VECTOR    = 1 shl 3; // Set if vector registers have been saved
  ECF_VRSAVE    = 1 shl 4; // Set if VRSAVE reflects state of vector registers saved

// Flags for ReadTaskContext/WriteTaskContext
// enRTCFlags
  RTCF_SPECIAL  = 1 shl 0;
  RTCF_STATE    = 1 shl 1;
  RTCF_GENERAL  = 1 shl 2;
  RTCF_FPU      = 1 shl 3;
  RTCF_VECTOR   = 1 shl 4;
  RTCF_INFO     = 1 shl 5;

  SIH_PRIMASK = $F0;
//**********************************************************************
// this is a fake INT definition, used only for AddIntServer and the like
  INTB_NMI    = 15;
  INTF_NMI    = 1 shl INTB_NMI;

//  These are used with AddIntServer/SetIntVector to install global
// trap handlers and with SetTaskTrap to install local task traps
// Note: Use of these global trap handlers should be
// restricted to system and debugger use. You should normally
// use the task's local trap handler.

// enTrapNumbers
  TRAPNUM_BUS_ERROR              = $01000000; // Bus error exception/machine check
  TRAPNUM_DATA_SEGMENT_VIOLATION = $02000000; // Data segment violation
  TRAPNUM_INST_SEGMENT_VIOLATION = $03000000; // Instruction segment violation
  TRAPNUM_ALIGNMENT              = $04000000; // Alignment violation
  TRAPNUM_ILLEGAL_INSTRUCTION    = $05000000; // Illegal instruction
  TRAPNUM_PRIVILEGE_VIOLATION    = $06000000; // Privilege violation
  TRAPNUM_TRAP                   = $07000000; // Trap instruction
  TRAPNUM_FPU                    = $08000000; // Floating point related (FPU disabled; imprecise)
  TRAPNUM_TRACE                  = $09000000; // Single step trace exception
  TRAPNUM_DATA_BREAKPOINT        = $0a000000; // Data breakpoint
  TRAPNUM_INST_BREAKPOINT        = $0b000000; // Instruction breakpoint
  TRAPNUM_PERFORMANCE            = $0c000000; // Performance monitor (System use only)
  TRAPNUM_THERMAL                = $0d000000; // Thermal management (System use only)
  TRAPNUM_RESERVED1              = $0e000000; // reserved
  TRAPNUM_ALTIVEC_ASSIST         = $0f000000; // AltiVec Assist
  TRAPNUM_SMI                    = $10000000; // System Management interrupt

  TRAPNUM_NUMTRAPS               = 16;          // Number of hardware traps

// Every Amiga Task has one of these Task structures associated with it.
// To find yours, use FindTask(Nil).  AmigaDOS processes tack a few more
// values on to the end of this structure, which is the difference between
// Tasks and Processes.
type
  PTask = ^TTask;
  TTask = record
    tc_Node: TNode;
    tc_Flags: Byte;
    tc_State: Byte;
    tc_IDNestCnt: ShortInt; // intr disabled nesting
    tc_TDNestCnt: ShortInt; // task disabled nesting
    tc_SigAlloc: LongWord;  // sigs allocated
    tc_SigWait: LongWord;   // sigs we are waiting for
    tc_SigRecvd: LongWord;  // sigs we have received
    tc_SigExcept: LongWord; // sigs we will take excepts for
      //The following field used to be this tc_TrapAlloc, tc_TrapAble, It was replaced by a pointer to an private extended task structure.
    tc_ETask: APTR;
    tc_ExceptData: APTR;    // points to except data
    tc_ExceptCode: APTR;    // points to except code
    tc_TrapData: APTR;      // points to trap data
    tc_TrapCode: APTR;      // points to trap code
    tc_SPReg: APTR;         // stack APTR
    tc_SPLower: APTR;       // stack lower bound
    tc_SPUpper: APTR;       // stack upper bound + 2
    tc_Switch: TProcedure;  // task losing CPU
    tc_Launch: TProcedure;  // task getting CPU
    tc_MemEntry: TList;     // allocated memory
    tc_UserData: APTR;      // per task data
  end;

// Stack swap structure as passed to StackSwap()
  PStackSwapStruct = ^TStackSwapStruct;
  TStackSwapStruct = record
    stk_Lower: APTR;     // Lowest byte of stack
    stk_Upper: LongWord; // Upper end of stack (size + Lowest)
    stk_Pointer: APTR;   // Stack pointer at switch point
  end;

// ----- Flag Bits ------------------------------------------
const
// enTaskFlagsBits
  TB_PROCTIME         = 0;
  TB_ETASK            = 3;
  TB_STACKCHK         = 4;
  TB_EXCEPT           = 5;
  TB_SWITCH           = 6;
  TB_LAUNCH           = 7;
// enTaskFlags
  TF_PROCTIME         = 1;
  TF_ETASK            = 8;
  TF_STACKCHK         = 16;
  TF_EXCEPT           = 32;
  TF_SWITCH           = 64;
  TF_LAUNCH           = 128;

// ----- Task States ----------------------------------------
// enTaskState
  TS_INVALID          = 0;
  TS_ADDED            = 1;
  TS_RUN              = 2;
  TS_READY            = 3;
  TS_WAIT             = 4;
  TS_EXCEPT           = 5;
  TS_REMOVED          = 6;
  TS_CRASHED          = 7;
  TS_SUSPENDED        = 8;

// ----- Predefined Signals -------------------------------------
// enTaskSignalBits
  SIGB_ABORT          = 0;
  SIGB_CHILD          = 1;
  SIGB_BLIT           = 4;
  SIGB_SINGLE         = 4;
  SIGB_INTUITION      = 5;
  SIGB_NET            = 7;
  SIGB_DOS            = 8;

// enTaskSignal
  SIGF_ABORT     = 1 shl SIGB_ABORT;
  SIGF_CHILD     = 1 shl SIGB_CHILD;
  SIGF_BLIT      = 1 shl SIGB_BLIT;
  SIGF_SINGLE    = 1 shl SIGB_SINGLE;
  SIGF_INTUITION = 1 shl SIGB_INTUITION;
  SIGF_NET       = 1 shl SIGB_NET;
  SIGF_DOS       = 1 shl SIGB_DOS;

// enSuspendBits
  STB_CRASHED = 0;
  STB_REMOVED = 1;

// enSuspendFlags
  STF_CRASHED = 1 shl STB_CRASHED;
  STF_REMOVED = 1 shl STB_REMOVED;

// This file defines ports and messages, which are used for inter-
// task communications using the routines defined toward the
// bottom of this file.
type
// ****** MsgPort ******************************************************
  PMsgPort = ^TMsgPort;
  TMsgPort = record
    mp_Node: TNode;
    mp_Flags: Byte;
    mp_SigBit: Byte;   // signal bit number
    mp_SigTask: APTR;  // task to be signalled (TaskPtr)
    mp_MsgList: TList; // message linked list
  end;

// ****** Message ******************************************************

  PMessage = ^TMessage;
  TMessage =  record
    mn_Node: TNode;
    mn_ReplyPort: PMsgPort; // message reply port
    mn_Length: Word;        // total message length, in bytes, (include the size of the Message structure in the length)
   end;

// mp_Flags: Port arrival actions (PutMsg)
const
// enMsgPortFlags
  PF_ACTION  = 3;        // Mask
  PF_SIGALLOC = 1 shl 7; // Internal use

// enMsgPortActions
  PA_SIGNAL  = 0; // Signal task in mp_SigTask
  PA_SOFTINT = 1; // Signal SoftInt in mp_SoftInt/mp_SigTask
  PA_IGNORE  = 2; // Ignore arrival


// ****** SignalSemaphore **********************************************
type
// Private structure used by ObtainSemaphore()
  PSemaphoreRequest = ^TSemaphoreRequest;
  TSemaphoreRequest = record
    sr_Link: TMinNode;
    sr_Waiter: PTask;
  end;

// Signal Semaphore data structure
  PSignalSemaphore = ^TSignalSemaphore;
  TSignalSemaphore = record
      ss_Link: TNode;
      ss_NestCount: SmallInt;
      ss_WaitQueue: TMinList;
      ss_MultipleLink: TSemaphoreRequest;
      ss_Owner: PTask;
      ss_QueueCount: SmallInt;
  end;

// ***** Semaphore procure message (for use in V39 Procure/Vacate ***
  PSemaphoreMessage = ^TSemaphoreMessage;
  TSemaphoreMessage = record
    ssm_Message: TMessage;
    ssm_Semaphore: PSignalSemaphore;
  end;

const
// enSemaphoreRequestType
 SM_SHARED      = 1;
 SM_EXCLUSIVE   = 0;

const
// ------ Special constants ---------------------------------------
// Note: This only applies to "legacy" 68k-based functions
  LIB_VECTSIZE  =  6;   //  Each library entry takes 6 bytes
  LIB_RESERVED  =  4;   //  Exec reserves the first 4 vectors
  LIB_BASE      = -LIB_VECTSIZE;
  LIB_USERDEF   = LIB_BASE - (LIB_RESERVED * LIB_VECTSIZE);
  LIB_NONSTD    = LIB_USERDEF;

// ------ Standard functions --------------------------------------
// Note: This only applies to "legacy" 68k-based functions
  LIB_OPEN    =  -6;
  LIB_CLOSE   = -12;
  LIB_EXPUNGE = -18;
  LIB_EXTFUNC = -24;  // for future expansion

type
// ------ Library Base Structure ----------------------------------
//  Also used for Devices and some Resources

  PLibrary = ^TLibrary;
  TLibrary =  record
    lib_Node: TNode;
    lib_Flags: Byte;
    lib_ABIVersion: Byte; // ABI exported by library
    lib_NegSize: Word;    // number of bytes before library
    lib_PosSize: Word;    // number of bytes after library
    lib_Version: Word;    // major
    lib_Revision: Word;   // minor
    lib_IdString: STRPTR; // ASCII identification
    lib_Sum: LongWord;    // the checksum itself  }
    lib_OpenCnt: Word;    // number of current opens  }
  end;   // Warning: size is not a longword multiple!

const

// lib_ABIVersion definitions
// enABIVersion
  LIBABI_68K    = 0; // A 68k library (pre OS4)
  LIBABI_MIFACE = 1; // V50 multi interface library

// lib_Flags bit definitions (all others are system reserved)
  LIBF_SUMMING = 1 shl 0; // we are currently checksumming
  LIBF_CHANGED = 1 shl 1; // we have just changed the lib
  LIBF_SUMUSED = 1 shl 2; // set if we should bother to sum
  LIBF_DELEXP  = 1 shl 3; // delayed expunge
  LIBF_EXP0CNT = 1 shl 4;


// This file defines the constants and types required to use
// Amiga device IO routines, which are also defined here.

type

//***** Device *********************************************************
  PDevice = ^TDevice;
  TDevice =  record
    dd_Library: TLibrary;
  end;

//***** Unit ***********************************************************
  PUnit = ^TUnit;
  TUnit = record
      unit_MsgPort: TMsgPort; // queue for unprocessed messages instance of msgport is recommended
      unit_flags: Byte;
      unit_pad: Byte;
      unit_OpenCnt: Word;     // number of active opens
  end;

const
  UNITF_ACTIVE  = 1 shl 0;
  UNITF_INTASK  = 1 shl 1;

type
  PIORequest = ^TIORequest;
  TIORequest =  record
    io_Message: TMessage;
    io_Device: PDevice; // device node pointer
    io_Unit: PUnit;     // unit (driver private)
    io_Command: Word;   // device command
    io_Flags: Byte;
    io_Error: ShortInt; // error or warning num
  end;

  PIOStdReq = ^TIOStdReq;
  TIOStdReq =  record
    io_Message: TMessage;
    io_Device: PDevice;  // device node pointer
    io_Unit: PUnit;      // unit (driver private)
    io_Command: Word;    // device command
    io_Flags: Byte;
    io_Error: ShortInt;  // error or warning num
    io_Actual: LongWord; // actual number of bytes transferred
    io_Length: LongWord; // requested number bytes transferred
    io_Data: APTR;       // points to data area
    io_Offset: LongWord; // offset for block structured devices
  end;


// library vector offsets for device reserved vectors }
const
// enum enDeviceLibraryReserved
  DEV_beginIO = -30;
  DEV_ABORTIO = -36;

// io_Flags defined bits

  IOB_QUICK   = 0;
  IOF_QUICK   = 1 shl IOB_QUICK;

// enDefaultDeviceCommands
  CMD_INVALID = 0;
  CMD_RESET   = 1;
  CMD_READ    = 2;
  CMD_WRITE   = 3;
  CMD_UPDATE  = 4;
  CMD_CLEAR   = 5;
  CMD_STOP    = 6;
  CMD_START   = 7;
  CMD_FLUSH   = 8;

  CMD_NONSTD  = 9;

//**********************************************************************
// The interface is the new way for exec libraries.
// Basically, the interface is embedded in a table of
// function pointers similar to the old library jump table.
//
// FIXME: Add some more documentation
{$PACKRECORDS C}

type
  TOS4InterfaceData = record
    Link: TNode;             // Node for linking several interfaces
    LibBase: PLibrary;       // Library this interface belongs to

    RefCount: LongWord;      // Reference count
    Version: LongWord;       // Version number of the interface
    Flags: LongWord;         // Various flags (see below)
    CheckSum: LongWord;      // Checksum of the interface
    PositiveSize: LongWord;  // Size of the function pointer part, (with this struct)
    NegativeSize: LongWord;  // Size of the data area
    IExecPrivate: APTR;      // Private copy of IExec
    EnvironmentVector: APTR; // Base address for base relative code
    Reserved3: LongWord;
    Reserved4: LongWord;
  end;

  TOS4Interface = record
    Data: TOS4InterfaceData;
    // some functions, calling convention?
  end;
  POS4Interface = ^TOS4Interface;

{$PACKRECORDS 2}

const
// Flags for the Flags field in interfaces and as flags parameter for GetInterface
// enInterfaceFlags
  IFLF_NONE          = $0000; // No flags
  IFLF_PROTECTED     = $0001; // This interface can't be SetMethod'd
  IFLF_NOT_NATIVE    = $0002; // Interface is 68k
  IFLF_PRIVATE       = $0004; // Interface is a private, non-shareable instance
  IFLF_CHANGED       = $0008; // Interface has been changed, ready for re-summing
  IFLF_UNMODIFIED    = $0010; // Interface is unmodified. This flag will be set
                               // if the interface is created, and reset as soon
                               // as someone uses SetMethod on it.
  IFLF_CLONED        = $0020; // Interface was created by Clone method and will
                               // have to be freed via Expunge(). Interface
                               // implementors must set this bit in Clone().
  IFLF_CLONE_EXPUNGE = $0040;  // Call Expunge() on cloned interface when the
                               // reference count reaches zero. (V53.31)


//  Definition of the Exec library base structure (pointed to by location 4).
// Most fields are not to be viewed or modified by user programs.  Use
// extreme caution.

type
  PExecBase = ^TExecBase;
  TExecBase =  Record
    LibNode: TLibrary; //  Standard library node

// ******* Static System Variables *************************************

    SoftVer: Word;          // kickstart release number (obs.)
    LowMemChkSum: SmallInt; // checksum of 68000 trap vectors
    ChkBase: LongWord;      // system base pointer complement
    ColdCapture: APTR;      //  coldstart soft capture vector
    CoolCapture: APTR;      //  coolstart soft capture vector
    WarmCapture: APTR;      //  warmstart soft capture vector
    SysStkUpper: APTR;      //  system stack base   (upper bound)
    SysStkLower: APTR;      //  top of system stack (lower bound)
    MaxLocMem: LongWord;    //  top of chip memory
    DebugEntry: APTR;       //  global debugger entry point
    DebugData: APTR;        //  global debugger data segment
    AlertData: APTR;        //  alert data segment
    MaxExtMem: APTR;        //  top of extended mem, or nil if none

    ChkSum: Word;           //  for all of the above (minus 2)

// ****** Interrupt Related ********************************************

    IntVects: array[0..15] of TIntVector;

// ****** Dynamic System Variables *************************************

    ThisTask: PTask;     // pointer to current task (readable)

    IdleCount: LongWord; //  idle counter
    DispCount: LongWord; //  dispatch counter
    Quantum: Word;       //  time slice quantum
    Elapsed: Word;       //  current quantum ticks
    SysFlags: Word;      //  misc internal system flags
    IDNestCnt: ShortInt; //  interrupt disable nesting count
    TDNestCnt: ShortInt; //  task disable nesting count

    AttnFlags: Word;     //  special attention flags (readable)

    AttnResched: Word;   //  rescheduling attention
    ResModules: APTR;    //  resident module array pointer
    TaskTrapCode: APTR;
    TaskExceptCode: APTR;
    TaskExitCode: APTR;
    TaskSigAlloc: LongWord;
    TaskTrapAlloc: Word;


// ****** System Lists (private!) **************************************

    MemList: TList;
    ResourceList: TList;
    DeviceList: TList;
    IntrList: TList;
    LibList: TList;
    PortList: TList;
    TaskReady: TList;
    TaskWait: TList;

    SoftInts: array[0..4] of TSoftIntList;

// ****** Other Globals ************************************************

    LastAlert: array[0..3] of LongInt;

    // these next two variables are provided to allow
    // system developers to have a rough idea of the
    // period of two externally controlled signals --
    // the time between vertical blank interrupts and the
    // external line rate (which is counted by CIA A's
    // "time of day" clock).  In general these values
    // will be 50 or 60, and may or may not track each
    // other.  These values replace the obsolete AFB_PAL
    // and AFB_50HZ flags.
    VBlankFrequency: Byte;      //  (readable)
    PowerSupplyFrequency: Byte; //  (readable)

    SemaphoreList: TList;

    // these next two are to be able to kickstart into user ram.
    // KickMemPtr holds a singly linked list of MemLists which
    // will be removed from the memory list via AllocAbs.  If
    // all the AllocAbs's succeeded, then the KickTagPtr will
    // be added to the rom tag list.
    KickMemPtr: APTR;    //  ptr to queue of mem lists
    KickTagPtr: APTR;    //  ptr to rom tag queue
    KickCheckSum: APTR;  //  checksum for mem and tags

// ****** V36 Exec additions start here ********************************

    ex_Pad0: Word;            // Private internal use
    ex_LaunchPoint: LongWord; // Private to Launch/Switch
    ex_RamLibPrivate: APTR;

    //  The next LongWord contains the system "E" clock frequency,
    // expressed in Hertz.  The E clock is used as a timebase for
    // the Amiga's 8520 I/O chips. (E is connected to "02").
    // Typical values are 715909 for NTSC, or 709379 for PAL.
    ex_EClockFrequency: LongWord; //  (readable)
    ex_CacheControl: LongWord;    //  Private to CacheControl calls
    ex_TaskID: LongWord;          //  Next available task ID

    ex_Reserved1: array[0..4] of LongWord;

    ex_MMULock: APTR;    //  private

    ex_Reserved2: array[0..2] of LongWord;

// ****** V39 Exec additions start here ********************************

    // The following list and data element are used
    //for V39 exec's low memory handler...
    ex_MemHandlers: TMinList; // The handler list
    ex_MemHandler: APTR;      // Private! handler pointer

// ****** V50 Exec additions start here ********************************

    MainInterface: PInterface; // ExecLibrary's primary interface
    Private01: APTR;
    Private02: LongWord;
    Private03: APTR;
    Private04: APTR;
    Private05: APTR;
    Private06: TList;
    Private07: APTR;
    EmuWS: APTR;          // Emulator Workspace. Legacy libraries might access this field
  // Yes, there are more additions, but you don't need to know what it is
  end;

// ***** Bit defines for AttnFlags (see above) *************************

// Processors and Co-processors:
// enAttnFlagBits
const
  AFB_68010     = 0; // also set for 68020
  AFB_68020     = 1; // also set for 68030
  AFB_68030     = 2; // also set for 68040
  AFB_68040     = 3; // also set for 68060
  AFB_68881     = 4; // also set for 68882
  AFB_68882     = 5;
  AFB_FPU40     = 6; // Set if 68040 FPU
  AFB_68060     = 7;

  // The following flags are new to V50
  AFB_603     =  8;
  AFB_604     =  9;
  AFB_750     = 10;
  AFB_7400    = 11;
  AFB_ALTIVEC = 12;
  AFB_4XX     = 13;
  AFB_OTHER   = 14;

// The AFB_FPU40 bit is set when a working 68040 FPU
// is in the system.  If this bit is set and both the
// AFB_68881 and AFB_68882 bits are not set, then the 68040
// math emulation code has not been loaded and only 68040
// FPU instructions are available.  This bit is valid *ONLY*
// if the AFB_68040 bit is set.
// Likewise, AFB_ALTIVEC identifies an existing AltiVec unit.

  AFB_PRIVATE = 15; // Just what it says

// enAttnFlags
  AFF_68010   = 1 shl  0;
  AFF_68020   = 1 shl  1;
  AFF_68030   = 1 shl  2;
  AFF_68040   = 1 shl  3;
  AFF_68881   = 1 shl  4;
  AFF_68882   = 1 shl  5;
  AFF_FPU40   = 1 shl  6;
  AFF_68060   = 1 shl  7;

  AFF_603     = 1 shl  8;
  AFF_604     = 1 shl  9;
  AFF_750     = 1 shl 10;
  AFF_7400    = 1 shl 11;
  AFF_ALTIVEC = 1 shl 12;
  AFF_4XX     = 1 shl 13;
  AFF_OTHER   = 1 shl 14;

  AFF_PRIVATE = 1 shl 15;


//***** Selected flag definitions for Cache manipulation calls *********
  CACRF_EnableI       = 1 shl  0; // Enable instruction cache
  CACRF_FreezeI       = 1 shl  1; // Freeze instruction cache
  CACRF_ClearI        = 1 shl  3; // Clear instruction cache
  CACRF_IBE           = 1 shl  4; // Instruction burst enable
  CACRF_EnableD       = 1 shl  8; // Enable data cache
  CACRF_FreezeD       = 1 shl  9; // Freeze data cache
  CACRF_ClearD        = 1 shl 11; // Clear data cache (flush to memory first)
  CACRF_DBE           = 1 shl 12; // 68030 Data burst enable
  CACRF_WriteAllocate = 1 shl 13; // 68030 Write-Allocate mode (must always be set!)
  CACRF_InvalidateD   = 1 shl 15; // Invalidate data cache (no writeback)
  CACRF_EnableE       = 1 shl 30; // Master enable for external caches.
                                        // External caches should track the
                                        // state of the internal caches
                                        // such that they do not cache anything
                                        // that the internal cache turned off
                                        // for.
  CACRF_CopyBack      = 1 shl 31; // Master enable for copyback caches

// enDMAFlags
  DMA_Continue     = 1 shl 1;      // Continuation flag for CachePreDMA
  DMAF_Continue    = DMA_Continue;
  DMA_NoModify     = 1 shl 2;      // Set if DMA does not update memory
  DMAF_NoModify    = DMA_NoModify;
  DMA_ReadFromRAM  = 1 shl 3;      // Set if DMA goes *FROM* RAM to device
  DMAF_ReadFromRAM = DMA_ReadFromRAM;

// The only fixed address in the Amiga memory space.
  AbsExecBase: PExecBase = Pointer(4);

// Don't even think about the contents of this structure. Just embed it and reference it
type
  PAVLNode = ^TAVLNode;
  TAVLNode = record
    Reserved: array[0..3] of LongWord;
  end;
  PPAVLNode = ^PAVLNode;

  TAVLKey = Pointer;

  PAVLNODECOMP = ^AVLNODECOMP;
  AVLNODECOMP = APTR;

  PAVLKEYCOMP = ^AVLKEYCOMP;
  AVLKEYCOMP = APTR;

const
// Minimum size of the buffers to receive disassembled opcodes
// and operands including the NIL string terminator.
  LEN_DISASSEMBLE_OPCODE_STRING   = 15;
  LEN_DISASSEMBLE_OPERANDS_STRING = 40;

type
// The StackFrameMsg is used when traversing a Task's stack.
  TStackFrameMsg = record
    StructSize: LongWord;    // Size of the data structure
    State: LongWord;         // State of the stack frame
    MemoryAddress: APTR;     // Memory address being pointed to
    StackPointer: PLongWord; // The stack pointer itself
  end;

const
//enStackFrameMsgState
  STACK_FRAME_DECODED               = 1;  // Decoded stack frame
  STACK_FRAME_INVALID_BACKCHAIN_PTR = 2;  // Invalid backchain pointer
  STACK_FRAME_TRASHED_MEMORY_LOOP   = 3;  // Memory loop caused by trashed memory
  STACK_FRAME_BACKCHAIN_PTR_LOOP    = 4;   // Backchain pointer loops

// Each DebugSymbol corresponds to some memory address.
type
  TDebugSymbol = record
    StructSize: LongWord;       // Size of the data structure
    Type_: LongWord;            // Type of debug symbol

    Name: STRPTR;               // Module name (may be NULL)
    Offset: LongWord;           // Offset into the module
    SegmentNumber: LongWord;    // DOS segment number
    SegmentOffset: LongWord;    // DOS segment offset

    SourceFileName: STRPTR;     // Source code file name (may be NULL)
    SourceLineNumber: LongWord; // Source code line number (may be zero)
    SourceFunctionName: STRPTR; // Source code function name (may be NULL)
    SourceBaseName: STRPTR;     // Source code base name (may be NULL)
  end;

const
// enDebugSymbolType
  DEBUG_SYMBOL_68K_MODULE    = 1; // 68K kernel module
  DEBUG_SYMBOL_NATIVE_MODULE = 2; // Kernel data module
  DEBUG_SYMBOL_KERNEL_MODULE = 3; // Kernel module
  DEBUG_SYMBOL_MODULE        = 4; // Module
  DEBUG_SYMBOL_MODULE_STABS  = 5; // Module with stabs debug

type
// Opaque datatype for the result of StartDebugOutputNotify.
  TDebugOutputNotify = record
  end;

// he task that should be signaled with the given
// signal mask when the debug output buffer was updated.
const
  SDONA_Task = TAG_USER + $1021000; // PTask
// The signal mask that shall be used
  SDONA_SignalMask = TAG_USER + $1021001; // LongWord

type
//**********************************************************************
// The following structure can be used to switch from 68k into PPC code,
// in general its use is discouraging but necessary in a few places.
  TEmuTrapfunction = procedure(Reg68K: PLongWord);

  TEmuTrap = record
    Instruction: LongWord;      // TRAPINST, see below
    Type_: Byte;                // TRAPTYPE or TRAPTYPENR
    Function_: TEmutrapFunction; // PPC function address also see "enRegConst" below but watch out byteoffsets!
  end;

const
  TRAPINST   = $4ef80000;  // jmp.w 0, indicate switch
  TRAPTYPE   = $0004;      // type of this trap (result in r3/d0)
  TRAPTYPENR = $0005;      // same as above but no return value

//**********************************************************************

// enRegConst
  REG68K_D0  =   0;
  REG68K_D1  =   4;
  REG68K_D2  =   8;
  REG68K_D3  =  12;
  REG68K_D4  =  16;
  REG68K_D5  =  20;
  REG68K_D6  =  24;
  REG68K_D7  =  28;
  REG68K_A0  =  32;
  REG68K_A1  =  36;
  REG68K_A2  =  40;
  REG68K_A3  =  44;
  REG68K_A4  =  48;
  REG68K_A5  =  52;
  REG68K_A6  =  56;
  REG68K_A7  =  60;

  REG68K_FP0 =  64;
  REG68K_FP1 =  72;
  REG68K_FP2 =  80;
  REG68K_FP3 =  88;
  REG68K_FP4 =  96;
  REG68K_FP5 = 104;
  REG68K_FP6 = 112;
  REG68K_FP7 = 120;

//**********************************************************************
// Tag Items for Emulate() system call

  ET_RegisterD0     = TAG_USER +  1;
  ET_RegisterD1     = TAG_USER +  2;
  ET_RegisterD2     = TAG_USER +  3;
  ET_RegisterD3     = TAG_USER +  4;
  ET_RegisterD4     = TAG_USER +  5;
  ET_RegisterD5     = TAG_USER +  6;
  ET_RegisterD6     = TAG_USER +  7;
  ET_RegisterD7     = TAG_USER +  8;

  ET_RegisterA0     = TAG_USER +  9;
  ET_RegisterA1     = TAG_USER + 10;
  ET_RegisterA2     = TAG_USER + 11;
  ET_RegisterA3     = TAG_USER + 12;
  ET_RegisterA4     = TAG_USER + 13;
  ET_RegisterA5     = TAG_USER + 14;
  ET_RegisterA6     = TAG_USER + 15;
  ET_RegisterA7     = TAG_USER + 16;

  ET_NoJIT          = TAG_USER + 17;

  ET_FPRegisters    = TAG_USER + 18;
  ET_FPRegisterMask = TAG_USER + 19;

  ET_SuperState     = TAG_USER + 20;

  ET_Offset         = TAG_USER + 21;

  ET_StackPtr       = TAG_USER + 22;

  ET_SaveRegs       = TAG_USER + 23;
  ET_SaveParamRegs  = TAG_USER + 24;

//**********************************************************************
// enEmulateFPFlags

  EFPF_FP0 = 1;
  EFPF_FP1 = 1 shl 1;
  EFPF_FP2 = 1 shl 2;
  EFPF_FP3 = 1 shl 3;
  EFPF_FP4 = 1 shl 4;
  EFPF_FP5 = 1 shl 5;
  EFPF_FP6 = 1 shl 6;
  EFPF_FP7 = 1 shl 7;

//**********************************************************************
// enDeviceIOErrors

  IOERR_SUCCESS    =  0; // no error
  IOERR_OPENFAIL   = -1; // device/unit failed to open
  IOERR_ABORTED    = -2; // request terminated early [after AbortIO()]
  IOERR_NOCMD      = -3; // command not supported by device
  IOERR_BADLENGTH  = -4; // not a valid length (usually IO_LENGTH)
  IOERR_BADADDRESS = -5; // invalid address (misaligned or bad range)
  IOERR_UNITBUSY   = -6; // device opens ok, but requested unit is busy
  IOERR_SELFTEST   = -7; // hardware failed self-test

//**********************************************************************
//Tag items used by AllocSysObject

  ASO_NoTrack         = TAG_USER +  1; // Don't track this object (i.e. do not free automatically;
  ASO_MemoryOvr       = TAG_USER +  2; // Memory type override
// IORequest
  ASOIOR_Size         = TAG_USER + 10; // Size of the object
  ASOIOR_ReplyPort    = TAG_USER + 11; // ReplyPort to use
  ASOIOR_Duplicate    = TAG_USER + 12; // Source IO request to duplicate
// Hook
  ASOHOOK_Size        = TAG_USER + 10; // Size of the object
  ASOHOOK_Entry       = TAG_USER + 11; // The hook's entry
  ASOHOOK_Subentry    = TAG_USER + 12; // The hook's subentry field
  ASOHOOK_Data        = TAG_USER + 13; // The hook's user data
// Interrupt
  ASOINTR_Size        = TAG_USER + 10; // Size of the object
  ASOINTR_Code        = TAG_USER + 11; // Code pointer
  ASOINTR_Data        = TAG_USER + 12; // Data pointer
  ASOINTR_SoftInt     = TAG_USER + 13; // Interrupt is used by Cause(;
// List
  ASOLIST_Size        = TAG_USER + 10; // Size of the object
  ASOLIST_Type        = TAG_USER + 11; // Type to set for the list
  ASOLIST_Min         = TAG_USER + 12; // Create a minlist
// DMAEntry array
  ASODMAE_Size        = TAG_USER + 10; // Raw size of the object
  ASODMAE_NumEntries  = TAG_USER + 11; // Number of entries
// List node
  ASONODE_Size        = TAG_USER + 10; // Size of the node
  ASONODE_Min         = TAG_USER + 11; // Make it a MinNode
  ASONODE_Type        = TAG_USER + 12; // Node's type
  ASONODE_Pri         = TAG_USER + 13; // Node's priority
  ASONODE_Name        = TAG_USER + 14; // Pointer to a node string
// Message port
  ASOPORT_Size        = TAG_USER + 10; // Size of the object
  ASOPORT_AllocSig    = TAG_USER + 11; // Allocate a signal
  ASOPORT_Action      = TAG_USER + 12; // Action at message arrival (see ports.h, enMsgPortActions;
  ASOPORT_Pri         = TAG_USER + 13; // Priority used when the port is added to a list
  ASOPORT_Name        = TAG_USER + 14; // Name for the port
  ASOPORT_Signal      = TAG_USER + 15; // Preallocted signal number
  ASOPORT_Target      = TAG_USER + 16; // MsgPort's target, either a task, or a softint
  ASOPORT_Public      = TAG_USER + 17; // Make the port public
  ASOPORT_CopyName    = TAG_USER + 18; // Copy the name string
// Message
  ASOMSG_Size         = TAG_USER + 10; // Size of the object
  ASOMSG_ReplyPort    = TAG_USER + 11; // Reply port
  ASOMSG_Length       = TAG_USER + 12; // Message length
  ASOMSG_Name         = TAG_USER + 13; // Name to put into the node
// Signal semaphore
  ASOSEM_Size         = TAG_USER + 10; // Size of the object
  ASOSEM_Name         = TAG_USER + 11; // Name
  ASOSEM_Pri          = TAG_USER + 12; // Node's priority (only used on public semaphores;
  ASOSEM_Public       = TAG_USER + 13; // Semaphore is public and will be added to the system
  ASOSEM_CopyName     = TAG_USER + 14; // Copy the name string
// TagItem array
  ASOTAGS_Size        = TAG_USER + 10; // Raw size of the object, i.e. in bytes
  ASOTAGS_NumEntries  = TAG_USER + 11; // Number of tagitems
// Memory Pool
  ASOPOOL_MFlags      = TAG_USER + 10; // Memory flags/requirements for this pool
  ASOPOOL_Puddle      = TAG_USER + 11; // Size of each puddle
  ASOPOOL_Threshold   = TAG_USER + 12; // Largest alloction size that goes into the puddle
  ASOPOOL_Protected   = TAG_USER + 13; // Protect pool with a semaphore
  ASOPOOL_Name        = TAG_USER + 14; // Name for the pool (for informational purpose only;
  ASOPOOL_CopyName    = TAG_USER + 15; // Copy the name string
  ASOPOOL_LockMem     = TAG_USER + 16; // Lock memory allocated
// Item Pool
  ASOITEM_MFlags      = TAG_USER + 10; // Memory flags for the pool
  ASOITEM_ItemSize    = TAG_USER + 11; // Size of individual items
  ASOITEM_BatchSize   = TAG_USER + 12; // Amount of items to be allocated in one batch
  ASOITEM_MaxSize     = TAG_USER + 13; // Maximum amount of items allowed in pool
  ASOITEM_GCPolicy    = TAG_USER + 14; // Garbage collection policy
  ASOITEM_GCParameter = TAG_USER + 15; // Garbage collection parameter
  ASOITEM_Constructor = TAG_USER + 16; // Constructor hook
  ASOITEM_Destructor  = TAG_USER + 17; // Destructor hook
  ASOITEM_Protected   = TAG_USER + 18; // Protect pool with a semaphore
// Mutex
  ASOMUTEX_Recursive  = TAG_USER + 10; // Make mutex recursive
// ExtMem
  ASOEXTMEM_Size            = TAG_USER + 10; // Size of extended memory area
  ASOEXTMEM_AllocationPolicy  = TAG_USER + 11; // Allocation policy

// Item pool GCPolicy types
// enItemPoolGCPolicy
  ITEMGC_NONE       = 0;
  ITEMGC_AFTERCOUNT = 1;

// Ext Memory allocation policies
// enExtMemAllocationPolicy
  EXTMEMPOLICY_IMMEDIATE  = 0;
  EXTMEMPOLICY_DELAYED    = 1;
  EXTMEMPOLICY_ACCESS     = 2;

// Kernel memory cache
  ASOKMEM_Name        = TAG_USER + 10; // Name of the cache
  ASOKMEM_Type        = TAG_USER + 11; // Type, private or shared
  ASOKMEM_Size        = TAG_USER + 12; // Object size
  ASOKMEM_Alignment   = TAG_USER + 13; // Object Alignment
  ASOKMEM_Constructor = TAG_USER + 14; // Constructor
  ASOKMEM_Destructor  = TAG_USER + 15; // Destructor
  ASOKMEM_Colored     = TAG_USER + 16; // Use cache slab coloring
  ASOKMEM_Compact     = TAG_USER + 17; // Force cache to be compact, even if this means the slab internal
                                       // fragmentation will be above the threshold
// Kernel memory cache type
// enKMemCacheType
  KMEMT_PRIVATE     = 0;
  KMEMT_SHARED      = 1;

// Resource map
  ASORMAP_Base        = TAG_USER + 10; // Resource range base
  ASORMAP_Size        = TAG_USER + 11; // Resource range size
  ASORMAP_Quantum     = TAG_USER + 12; // Minimal quantum for one single allocation

  ASORMAP_CacheMax    = TAG_USER + 13; // Maximum size for quantum caches. All allocations smaller or equal
                                       // to this size will come from quantum caches

// Tags for AllocVecTagList (V51)
  AVT_Type              = TAG_USER + 1;
  AVT_Contiguous        = TAG_USER + 2;
  AVT_Lock              = TAG_USER + 3;
  AVT_Alignment         = TAG_USER + 4;
  AVT_PhysicalAlignment = TAG_USER + 5;
  AVT_Clear             = TAG_USER + 6;
  AVT_ClearWithValue    = TAG_USER + 6;
  AVT_ClearValue        = TAG_USER + 6;
  AVT_Wait              = TAG_USER + 7;
  AVT_NoExpunge         = TAG_USER + 8;

// Tags for AllocNamedMemory (V51)
  ANMT_CheckSum       = TAG_USER + 1;
  ANMT_Error          = TAG_USER + 2;

// Possible values for ANMT_Error
// enAllocNamedMemoryErrors
  ANMERROR_NOERROR        = 0;
  ANMERROR_NOMEMORY       = 1;
  ANMERROR_DUPLICATENAME  = 2;
  ANMERROR_PARAMETER      = 3;

// Tags for GetCPUInfo
  GCIT_NumberOfCPUs   = TAG_USER +  1;
  GCIT_Family         = TAG_USER +  2;
  GCIT_Model          = TAG_USER +  3;
  GCIT_ModelString    = TAG_USER +  4;
  GCIT_Version        = TAG_USER +  5;
  GCIT_VersionString  = TAG_USER +  6;
  GCIT_FrontsideSpeed = TAG_USER +  7;
  GCIT_ProcessorSpeed = TAG_USER +  8;
  GCIT_L1CacheSize    = TAG_USER +  9;
  GCIT_L2CacheSize    = TAG_USER + 10;
  GCIT_L3CacheSize    = TAG_USER + 11;
  GCIT_VectorUnit     = TAG_USER + 12;
  GCIT_Extensions     = TAG_USER + 13;
  GCIT_CacheLineSize  = TAG_USER + 14;
  GCIT_CPUPageSize    = TAG_USER + 15;
  GCIT_ExecPageSize   = TAG_USER + 16;
  GCIT_TimeBaseSpeed  = TAG_USER + 17;

// Family codes
//enCPUFamiliy
  CPUFAMILY_UNKNOWN = 0;
  CPUFAMILY_60X     = 1;
  CPUFAMILY_7X0     = 2;
  CPUFAMILY_74XX    = 3;
  CPUFAMILY_4XX     = 4;
  CPUFAMILY_PA6T    = 5;
  CPUFAMILY_E300    = 6;
  CPUFAMILY_E5500   = 7;

// Model codes
// enCPUModel
  CPUTYPE_UNKNOWN        =  0;
  CPUTYPE_PPC603E        =  1;
  CPUTYPE_PPC604E        =  2;
  CPUTYPE_PPC750CXE      =  3;
  CPUTYPE_PPC750FX       =  4;
  CPUTYPE_PPC750GX       =  5;
  CPUTYPE_PPC7410        =  6;
  CPUTYPE_PPC74XX_VGER   =  7;
  CPUTYPE_PPC74XX_APOLLO =  8;
  CPUTYPE_PPC405LP       =  9;
  CPUTYPE_PPC405EP       = 10;
  CPUTYPE_PPC405GP       = 11;
  CPUTYPE_PPC405GPR      = 12;
  CPUTYPE_PPC440EP       = 13;
  CPUTYPE_PPC440GP       = 14;
  CPUTYPE_PPC440GX       = 15;
  CPUTYPE_PPC440SX       = 16;
  CPUTYPE_PPC440SP       = 17;
  CPUTYPE_PA6T_1682M     = 18;
  CPUTYPE_PPC460EX       = 19;
  CPUTYPE_PPC5121E     = 20;
  CPUTYPE_P50XX      = 21;

// Vector unit types
// enVectorUnitType
  VECTORTYPE_NONE    = 0;
  VECTORTYPE_ALTIVEC = 1;
  // Same as AltiVec    VECTORTYPE_VMX     = 2

//**********************************************************************
// Object types for AllocSysObject

// enAllocSysObjectTypes
  ASOT_IOREQUEST =  0; // IORequest
  ASOT_HOOK      =  1; // Hook
  ASOT_INTERRUPT =  2; // Interrupt structure
  ASOT_LIST      =  3; // List and MinList
  ASOT_DMAENTRY  =  4; // DMAEntry array
  ASOT_NODE      =  5; // List node and MinNode
  ASOT_PORT      =  6; // Message port
  ASOT_MESSAGE   =  7; // Exec Message
  ASOT_SEMAPHORE =  8; // Signal Semaphore
  ASOT_TAGLIST   =  9; // TagItem list
  ASOT_MEMPOOL   = 10; // Memory pool
  ASOT_ITEMPOOL  = 11; // Item pool
  ASOT_RMAP      = 12; // Resource map
  ASOT_MUTEX     = 13; // Mutex
  ASOT_EXTMEM    = 14; // Extended memory

//**********************************************************************
// Tag items for CreateLibrary
  CLT_Vector68K     = TAG_USER +  1;
  CLT_InitData      = TAG_USER +  2;
  CLT_InitFunc      = TAG_USER +  3;
  CLT_Seglist       = TAG_USER +  8;
  CLT_Interfaces    = TAG_USER +  9;
  CLT_DataSize      = TAG_USER + 10;
  CLT_Legacy        = TAG_USER + 11;
  CLT_NoLegacyIFace = TAG_USER + 12;

//**********************************************************************
// Message types for debugger hook
// enDebugMessage
  DBHMT_EXCEPTION     = 1;
  DBHMT_REMTASK       = 2;
  DBHMT_OPENLIB       = 3;
  DBHMT_CLOSELIB      = 4;
  DBHMT_ADDTASK       = 5;
  DBHMT_SHAREDOBJECTOPEN  = 6;
  DBHMT_SHAREDOBJECTCLOSE = 7;

//**********************************************************************
// Tags for AddTask/CreateTask
  AT_Param1         = TAG_USER + 1;
  AT_Param2         = TAG_USER + 2;
  AT_Param3         = TAG_USER + 3;
  AT_Param4         = TAG_USER + 4;
  AT_Param5         = TAG_USER + 5;
  AT_Param6         = TAG_USER + 6;
  AT_Param7         = TAG_USER + 7;
  AT_Param8         = TAG_USER + 8;
  AT_Child          = TAG_USER + 9;

  CT_LockStack      = TAG_USER + 20;

//**********************************************************************
// Tags for NewStackRun
  NSR_Dummy         = TAG_USER + 500;    // Offset to avoid Emulate(; tag collision.
  NSR_StackSize     = NSR_Dummy + 1;     // Initial stack size
  NSR_MinStackSize  = NSR_Dummy + 2;     // Absolute minimal stack size
  NSR_LockStack     = NSR_Dummy + 3;     // Lock the stack in memory to prevent paging
  NSR_Arg1          = NSR_Dummy + 10;    // Parameters passed to the function
  NSR_Arg2          = NSR_Dummy + 11;
  NSR_Arg3          = NSR_Dummy + 12;
  NSR_Arg4          = NSR_Dummy + 13;
  NSR_Arg5          = NSR_Dummy + 14;
  NSR_Arg6          = NSR_Dummy + 15;

//**********************************************************************

{$PACKRECORDS DEFAULT}