juicebox flash.map

An complete pmp solution for mattel juicebox player. Using crossworks for arm.

                0x000001e0                __rodata_end__ = (__rodata_start__ + SIZEOF (.rodata))
                0x00000001                . = ASSERT (((__rodata_end__ >= __FLASH_segment_start__) && (__rodata_end__ <= (__FLASH_segment_start__ + 0x800000))), error: .rodata is too large to fit in FLASH memory segment)
                0x000001e0                __fast_load_start__ = (__rodata_end__ ALIGN 0x4)

.fast           0x0c00003c        0x0 load address 0x000001e0
                0x0c00003c                __fast_start__ = .
 *(.fast .fast.*)
                0x0c00003c                __fast_end__ = (__fast_start__ + SIZEOF (.fast))
                0x000001e0                __fast_load_end__ = (__fast_load_start__ + SIZEOF (.fast))
                0x00000001                . = ASSERT ((((__fast_load_start__ + SIZEOF (.fast)) >= __FLASH_segment_start__) && ((__fast_load_start__ + SIZEOF (.fast)) <= (__FLASH_segment_start__ + 0x800000))), error: .fast is too large to fit in FLASH memory segment)

.fast_run       0x0c00003c        0x0
                0x0c00003c                __fast_run_start__ = .
                0x0c00003c                . = ((__fast_run_start__ + SIZEOF (.fast)) MAX_K .)
                0x0c00003c                __fast_run_end__ = (__fast_run_start__ + SIZEOF (.fast_run))
                0x00000001                . = ASSERT (((__fast_run_end__ >= __SRAM_segment_start__) && (__fast_run_end__ <= (__SRAM_segment_start__ + 0x200000))), error: .fast_run is too large to fit in SRAM memory segment)
                0x000001e0                __data_load_start__ = ((__fast_load_start__ + SIZEOF (.fast)) ALIGN 0x4)

.data           0x0c00003c        0x0 load address 0x000001e0
                0x0c00003c                __data_start__ = .
 *(.data .data.* .gnu.linkonce.d.*)
                0x0c00003c                __data_end__ = (__data_start__ + SIZEOF (.data))
                0x000001e0                __data_load_end__ = (__data_load_start__ + SIZEOF (.data))
                0x000001e0                __FLASH_segment_used_end__ = (((__fast_load_start__ + SIZEOF (.fast)) ALIGN 0x4) + SIZEOF (.data))
                0x00000001                . = ASSERT ((((__data_load_start__ + SIZEOF (.data)) >= __FLASH_segment_start__) && ((__data_load_start__ + SIZEOF (.data)) <= (__FLASH_segment_start__ + 0x800000))), error: .data is too large to fit in FLASH memory segment)

.data_run       0x0c00003c        0x0
                0x0c00003c                __data_run_start__ = .
                0x0c00003c                . = ((__data_run_start__ + SIZEOF (.data)) MAX_K .)
                0x0c00003c                __data_run_end__ = (__data_run_start__ + SIZEOF (.data_run))
                0x00000001                . = ASSERT (((__data_run_end__ >= __SRAM_segment_start__) && (__data_run_end__ <= (__SRAM_segment_start__ + 0x200000))), error: .data_run is too large to fit in SRAM memory segment)
                0x0c00003c                __bss_load_start__ = (__data_run_end__ ALIGN 0x4)

.bss            0x0c00003c        0x0
                0x0c00003c                __bss_start__ = .
 *(.bss .bss.* .gnu.linkonce.b.*)
 *(COMMON)
                0x0c00003c                __bss_end__ = (__bss_start__ + SIZEOF (.bss))
                0x00000001                . = ASSERT (((__bss_end__ >= __SRAM_segment_start__) && (__bss_end__ <= (__SRAM_segment_start__ + 0x200000))), error: .bss is too large to fit in SRAM memory segment)
                0x0c00003c                __non_init_load_start__ = (__bss_end__ ALIGN 0x4)

.non_init       0x0c00003c        0x0
                0x0c00003c                __non_init_start__ = .
 *(.non_init .non_init.*)
                0x0c00003c                __non_init_end__ = (__non_init_start__ + SIZEOF (.non_init))
                0x00000001                . = ASSERT (((__non_init_end__ >= __SRAM_segment_start__) && (__non_init_end__ <= (__SRAM_segment_start__ + 0x200000))), error: .non_init is too large to fit in SRAM memory segment)
                0x0c00003c                __heap_load_start__ = (__non_init_end__ ALIGN 0x4)

.heap           0x0c00003c      0x400
                0x0c00003c                __heap_start__ = .
 *(.heap)
                0x0c00043c                . = ((__heap_start__ + __HEAPSIZE__) MAX_K .)
 *fill*         0x0c00003c      0x400 00
                0x0c00043c                __heap_end__ = (__heap_start__ + SIZEOF (.heap))
                0x00000001                . = ASSERT (((__heap_end__ >= __SRAM_segment_start__) && (__heap_end__ <= (__SRAM_segment_start__ + 0x200000))), error: .heap is too large to fit in SRAM memory segment)
                0x0c00043c                __stack_load_start__ = (__heap_end__ ALIGN 0x4)

.stack          0x0c00043c      0x400
                0x0c00043c                __stack_start__ = .
 *(.stack)
                0x0c00083c                . = ((__stack_start__ + __STACKSIZE__) MAX_K .)
 *fill*         0x0c00043c      0x400 00
                0x0c00083c                __stack_end__ = (__stack_start__ + SIZEOF (.stack))
                0x00000001                . = ASSERT (((__stack_end__ >= __SRAM_segment_start__) && (__stack_end__ <= (__SRAM_segment_start__ + 0x200000))), error: .stack is too large to fit in SRAM memory segment)
                0x0c00083c                __stack_irq_load_start__ = (__stack_end__ ALIGN 0x4)

.stack_irq      0x0c00083c      0x100
                0x0c00083c                __stack_irq_start__ = .
 *(.stack_irq)
                0x0c00093c                . = ((__stack_irq_start__ + __STACKSIZE_IRQ__) MAX_K .)
 *fill*         0x0c00083c      0x100 00
                0x0c00093c                __stack_irq_end__ = (__stack_irq_start__ + SIZEOF (.stack_irq))
                0x00000001                . = ASSERT (((__stack_irq_end__ >= __SRAM_segment_start__) && (__stack_irq_end__ <= (__SRAM_segment_start__ + 0x200000))), error: .stack_irq is too large to fit in SRAM memory segment)
                0x0c00093c                __stack_fiq_load_start__ = (__stack_irq_end__ ALIGN 0x4)

.stack_fiq      0x0c00093c      0x100
                0x0c00093c                __stack_fiq_start__ = .
 *(.stack_fiq)
                0x0c000a3c                . = ((__stack_fiq_start__ + __STACKSIZE_FIQ__) MAX_K .)
 *fill*         0x0c00093c      0x100 00
                0x0c000a3c                __stack_fiq_end__ = (__stack_fiq_start__ + SIZEOF (.stack_fiq))
                0x00000001                . = ASSERT (((__stack_fiq_end__ >= __SRAM_segment_start__) && (__stack_fiq_end__ <= (__SRAM_segment_start__ + 0x200000))), error: .stack_fiq is too large to fit in SRAM memory segment)
                0x0c000a3c                __stack_svc_load_start__ = (__stack_fiq_end__ ALIGN 0x4)

.stack_svc      0x0c000a3c        0x0
                0x0c000a3c                __stack_svc_start__ = .
 *(.stack_svc)
                0x0c000a3c                . = ((__stack_svc_start__ + __STACKSIZE_SVC__) MAX_K .)
                0x0c000a3c                __stack_svc_end__ = (__stack_svc_start__ + SIZEOF (.stack_svc))
                0x00000001                . = ASSERT (((__stack_svc_end__ >= __SRAM_segment_start__) && (__stack_svc_end__ <= (__SRAM_segment_start__ + 0x200000))), error: .stack_svc is too large to fit in SRAM memory segment)
                0x0c000a3c                __stack_abt_load_start__ = (__stack_svc_end__ ALIGN 0x4)

.stack_abt      0x0c000a3c        0x0
                0x0c000a3c                __stack_abt_start__ = .
 *(.stack_abt)
                0x0c000a3c                . = ((__stack_abt_start__ + __STACKSIZE_ABT__) MAX_K .)
                0x0c000a3c                __stack_abt_end__ = (__stack_abt_start__ + SIZEOF (.stack_abt))
                0x00000001                . = ASSERT (((__stack_abt_end__ >= __SRAM_segment_start__) && (__stack_abt_end__ <= (__SRAM_segment_start__ + 0x200000))), error: .stack_abt is too large to fit in SRAM memory segment)
                0x0c000a3c                __stack_und_load_start__ = (__stack_abt_end__ ALIGN 0x4)

.stack_und      0x0c000a3c        0x0
                0x0c000a3c                __stack_und_start__ = .
 *(.stack_und)
                0x0c000a3c                . = ((__stack_und_start__ + __STACKSIZE_UND__) MAX_K .)
                0x0c000a3c                __stack_und_end__ = (__stack_und_start__ + SIZEOF (.stack_und))
                0x0c000a3c                __SRAM_segment_used_end__ = ((__stack_abt_end__ ALIGN 0x4) + SIZEOF (.stack_und))
                0x00000001                . = ASSERT (((__stack_und_end__ >= __SRAM_segment_start__) && (__stack_und_end__ <= (__SRAM_segment_start__ + 0x200000))), error: .stack_und is too large to fit in SRAM memory segment)
START GROUP
LOAD ARM Flash Release/main.o
LOAD ARM Flash Release/Standard_ARM_Startup.o
LOAD ARM Flash Release/crt0.o
LOAD C:/Program Files/CrossWorks for ARM 1.6/lib/libarmdi_v4t_a_le.a
LOAD C:/Program Files/CrossWorks for ARM 1.6/lib/libm_v4t_a_le.a
LOAD C:/Program Files/CrossWorks for ARM 1.6/lib/libc_v4t_a_le.a
LOAD C:/Program Files/CrossWorks for ARM 1.6/lib/libcpp_v4t_a_le.a
LOAD C:/Program Files/CrossWorks for ARM 1.6/lib/libgccfp_v4t_a_le.a
LOAD C:/Program Files/CrossWorks for ARM 1.6/lib/lib_vfprintf_long_v4t_a_le.a
LOAD C:/Program Files/CrossWorks for ARM 1.6/lib/lib_vfscanf_long_v4t_a_le.a
END GROUP
OUTPUT(ARM Flash Release/JuiceBox flash.elf elf32-littlearm)

.comment        0x00000000       0x2b
 .comment       0x00000000       0x2b ARM Flash Release/main.o