RSEG CODE_I : CODE

        NAME    PWM_Data
        RSEG    PWM_DATA : DATA(0)
        ORG    0

FREQ_0            DS    1
FREQ_1            DS    1
Bitrate            DS    1
/* FFSK */
SinStep            DS    1
Quadrant        DS    1
BitPhase        DS    2
    ORG    SinStep
/* GFSK,GMSK */
Curve            DS    1
Shifter            DS    1
        ENDMOD

    RSEG CODE_I : CODE

extern void foo(void);

void main(void)
{
   foo();
   ...
   ....
}

        MODULE    ?foo         
        PUBLIC  foo        
            
         RSEG CODE_I : CODE      
           CODE32

Table1:     //всего 255 значений
      
       DC32                   0        //0
       DC32        2        //1
       DC32        6        //2
...
...
       DC32        1025        //255

Table2:     //всего 255 значений
      
       DC32                   0        //0
       DC32        20        //1
       DC32        60        //2
...
...
       DC32        4025        //255


foo                  

      mov   R4,#Table1  
      mov   R8,#Table2

       mov   PC,LR

       ENDMOD  
      
      END

Error[e18]: Range error, Number out of range
  Where $ = foo + 0x4  [0x40000804]
            in module "?foo" ,
            offset 0x804 in segment part 0, segment CODE_I
  What: foo [0x40000000]
  Allowed range: 0x0 - 0xFF
  Operand: foo [0x40000000]
           in module ?foo ,
           Offset 0x0 in segment part 0, segment CODE_I

      mov   R4,#Table1  
      mov   R8,#Table2

extern __ramfunc void foo(void);

UINT data[255] = {1,1,2,3,4,.........,234};
UINT data[255] = {1,2,3,4,....,255};

void main(void)
{
  foo();
}

                NAME    ?foo        
    PUBLIC  foo        
                RSEG  CODE_I : CODE  


foo:
              mov   R1,#10
              mov   R2,#20
              mov   PC,LR

      ENDMOD  
      
      END

/* Structure of an element in the segment initialization table
* in segment INITTAB. Used for both zero-initialization and copying. */
typedef struct
{
  long   Size;                  /* Number of bytes to initialize */
  char*  Dst;                   /* Destination. If Dst==Src, then init to 0 */
  char*  Src;                   /* Source address. Usually in ROM. */
} InitBlock_Type;

pragma location="ICODE"
__interwork void __segment_init(void)
{
  InitBlock_Type const * const initTableBegin = __sfb( "INITTAB" );
  InitBlock_Type const * const initTableEnd = __sfe( "INITTAB" );
  InitBlock_Type const * initTableP;

  /* Loop over all elements in the initialization table. */
  for (initTableP=initTableBegin; initTableP<initTableEnd; initTableP++)
  {
    /* If src=dest then we should clear a memory
     * block, otherwise it's a copy operation. */
    if (initTableP->Src == initTableP->Dst)
    {
      memset(initTableP->Dst, 0, initTableP->Size);
    }
    else
    {
      memcpy(initTableP->Dst, initTableP->Src, initTableP->Size);
    }
  }
}

    RSEG INITTAB:CODE
    dw  .....
    dw  .....
    dw  .....

#include <iolpc2103.h>

typedef unsigned int  UINT;
typedef unsigned short  USHORT;
typedef unsigned char UCHAR;

extern __ramfunc void __haffman(USHORT*  pHaff, USHORT* pHaffLen);

USHORT haffman[256] =
{
  0    ,    //0
2    ,    //1
6    ,    //2
...
32766    ,    //254
32767        //255

};

USHORT haffman_len_mask[256] =
{
0x0001    ,    //0
0x0002    ,    //1
...
0x4000        //255
};

USHORT* pHaff = haffman;
USHORT* pHaffMask = haffman_len_mask;

extern void _cpy(void);

void main()
{

  _cpy();
   __haffman(pHaff, pHaffMask);
  
  while(1){}
}

       MODULE    ?HAFFMAN
      
       RSEG     RAM_FUNC : CODE
        
       PUBLIC  __haffman        
       CODE32
      
       DC32  SFB(RAM_FUNC)
       DC32  SIZEOF(RAM_FUNC)      
        
__haffman:  
     //в R0 указатель на первый входной параметр функции
     // в данном случае указатель на таблицу констант хаффмана
    
     // в R1 указатель на второй входной параметр функции    
     // в данном случае указатель на таблицу длинн констант хаффмана
    
      mov   R2, #35       // data in  
      
      mov   R3,#0x01      // bit position
      
      mov   R10,#0x40000000  // адресс выходных данных
      orr   R10,R10,#0x1000
      mov   R11,#0
      str   R11,[R10]  
      
      mov   R11,#0xFF
      orr   R11,R11,R11, LSL #8  //R11 <- 0x0000FFFF      
      
repeat:  
      ldr  R4,[R0,R2, LSL #1]  //загрузить в R4 код HAFFMAN соответствующий входным данным
      
      orr   R4,R4,R5,LSL #8
      
      and   R4,R4,R11           // маскирование старших 16 бит
      
      mul  R5,R4,R3          // сдвигаем очередной код на текущую позицию
      
      ldr   R9,[R10]     // загружаем выходные данные из текущей позиции
      
      orr   R5,R5,R9    // добавляем новые данные
      
      str   R5,[R0]       // сохраняем новые данные
            
      cmp   R6,#0
      addne R0,R0,#4  
      
      ldr   R7,[R8,R2, LSL #1] //загрузить в R7 длину кода HAFFMAN соответствующий входным данным      
      
      LSL   R7,R7,#1
      
      muls  R5,R3,R7
      
      movcs R3, #0x01
      movcc R3,R5
      
      addcs R0,R0,#8
      
      b     repeat
      
      mov   PC,LR    //возврат из подпрограммы R15 (PC)- программный счетчих,
                        // R14 (LR) - регистр связи в нем автоматически сохраняется
                        // адрес возврата из подпрограммы  
      
      ENDMOD      
      END

      MODULE    ?CPY
      RSEG    CODE_ID : CODE
      PUBLIC    _cpy
      EXTERN    COPYD      
      CODE32
      
_cpy:  
       ldr     R0,COPYD        
       add     R5,R0,#4      
       ldr     R1,[R5],#+4        
       ldr     R2,[R5]
       sub     R2,R2,#1
       add     R0,R0,#4
      
_cpy_1:  ldrb    R12,[R0],#+1
         subs    R2,R2,#1
         strb    R12,[R1],#+1
         bne    _cpy_1
        
         mov   PC,LR          

      ENDMOD  
      
      MODULE    ?FLASH
      RSEG    FLASH :CODE      
      PUBLIC    COPYD        
      CODE32
      
COPYD:       DC32 SFB(FLASH)

      LTORG
      ENDMOD //?FLASH      
      END

-QCODE_I=CODE_ID

-Z(CODE)RAM_FUNC=40000000-40002000
-Z(CODE)FLASH=40-7FFF

-QRAM_FUNC=FLASH

void __haffman(USHORT*  pHaff, USHORT* pHaffLen);