Download project files.
project1.elf:  file format elf32-littlenios2
There are 21 section headers, starting at offset 0x231f8 (in project1.elf): Section Headers: [Nr] Name Type Addr Off Size ES Flg Lk Inf Al [ 0] NULL 00000000 000000 000000 00 0 0 0 [ 1] .entry PROGBITS 00800000 000074 000020 00 AX 0 0 32 [ 2] .exceptions PROGBITS 00800020 000094 0001a8 00 AX 0 0 4 [ 3] .text PROGBITS 008001c8 00023c 003af0 00 AX 0 0 4 [ 4] .rodata PROGBITS 00803cb8 003d2c 0001bc 00 A 0 0 4 [ 5] .rwdata PROGBITS 00803e74 003ee8 001b3c 00 WAp 0 0 4 [ 6] .bss NOBITS 008059b0 005a24 000214 00 WAp 0 0 4 [ 7] .sdram PROGBITS 00805bc4 005a24 000000 00 W 0 0 1
The .entry section contains (_reset) which intializes instruction cache and jumps to _start at the beginning of the .text section. (both routines are defined in crt0.S).
The _start routine does the following:
See symbol table.
The alt_load routine does the following:
The alt_main routine does the following:
See crt0.S.
00800000 <__reset>: /* Assume the instruction cache size is always a power of two. */ #if NIOS2_ICACHE_SIZE > 0x8000 movhi r2, %hi(NIOS2_ICACHE_SIZE) #else movui r2, NIOS2_ICACHE_SIZE 800000: 00840014 movui r2,4096 #endif 0: initi r2 800004: 1001483a initi r2 addi r2, r2, -NIOS2_ICACHE_LINE_SIZE 800008: 10bff804 addi r2,r2,-32 bgt r2, zero, 0b 80000c: 00bffd16 blt zero,r2,800004 <__alt_mem_sdram+0x4> 1: /* * The following debug information tells the ISS not to run the loop above * but to perform its actions using faster internal code. */ .pushsection .debug_alt_sim_info .int 1, 1, 0b, 1b .popsection #endif /* Initialize Instruction Cache */ /* * Jump to the _start entry point in the .text section if reset code * is allowed or if optimizing for RTL simulation. */ #if defined(ALT_ALLOW_CODE_AT_RESET) || defined(ALT_SIM_OPTIMIZE) /* Jump to the _start entry point in the .text section. */ movhi r1, %hi(_start) 800010: 00402034 movhi at,128 ori r1, r1, %lo(_start) 800014: 08407214 ori at,at,456 jmp r1 800018: 0800683a jmp at 80001c: 00000000 call 0 <__alt_mem_sdram-0x800000>
00800020 <alt_exception>: * caller saved registers on the stack (See the Nios2 ABI * documentation for details). */ addi sp, sp, -76 800020: deffed04 addi sp,sp,-76 #ifdef ALT_STACK_CHECK bltu sp, et, .Lstack_overflow #endif #endif stw ra, 0(sp) 800024: dfc00015 stw ra,0(sp) /* * Leave a gap in the stack frame at 4(sp) for the muldiv handler to * store zero into. */ stw r1, 8(sp) 800028: d8400215 stw at,8(sp) stw r2, 12(sp) 80002c: d8800315 stw r2,12(sp) stw r3, 16(sp) 800030: d8c00415 stw r3,16(sp) stw r4, 20(sp) 800034: d9000515 stw r4,20(sp) stw r5, 24(sp) 800038: d9400615 stw r5,24(sp) stw r6, 28(sp) 80003c: d9800715 stw r6,28(sp) stw r7, 32(sp) 800040: d9c00815 stw r7,32(sp) rdctl r5, estatus 800044: 000b307a rdctl r5,estatus stw r8, 36(sp) 800048: da000915 stw r8,36(sp) stw r9, 40(sp) 80004c: da400a15 stw r9,40(sp) stw r10, 44(sp) 800050: da800b15 stw r10,44(sp) stw r11, 48(sp) 800054: dac00c15 stw r11,48(sp) stw r12, 52(sp) 800058: db000d15 stw r12,52(sp) stw r13, 56(sp) 80005c: db400e15 stw r13,56(sp) stw r14, 60(sp) 800060: db800f15 stw r14,60(sp) stw r15, 64(sp) 800064: dbc01015 stw r15,64(sp) stw r5, 68(sp) 800068: d9401115 stw r5,68(sp) addi r15, ea, -4 /* re-issue the interrupted instruction */ 80006c: ebffff04 addi r15,ea,-4 stw r15, 72(sp) 800070: dbc01215 stw r15,72(sp) /* * Test to see if the exception was a software exception or caused * by an external interrupt, and vector accordingly. */ rdctl r4, ipending 800074: 0009313a rdctl r4,ipending andi r2, r5, 1 800078: 2880004c andi r2,r5,1 beq r2, zero, .Lnot_irq 80007c: 10000326 beq r2,zero,80008c <__ram_exceptions_start+0x6c> beq r4, zero, .Lnot_irq 800080: 20000226 beq r4,zero,80008c <__ram_exceptions_start+0x6c> #endif /* ALT_CI_INTERRUPT_VECTOR_N */ .section .exceptions.irqhandler, "xa" /* * Now that all necessary registers have been preserved, call * alt_irq_handler() to process the interrupts. */ call alt_irq_handler 800084: 08000ec0 call 8000ec <alt_irq_handler> .section .exceptions.irqreturn, "xa" br .Lexception_exit 800088: 00000306 br 800098 <__ram_exceptions_start+0x78> /* * The interrupt testing code goes here. If an interrupt is active * then it stores ea-4 into 72(sp), handles the interrupt and jumps to * .exceptions.exit. If there is no interrupt then it continues */ .section .exceptions.notirq, "xa" stw ea, 72(sp) /* Return after the instruction which caused the exception */ 80008c: df401215 stw ea,72(sp) ldw r2, -4(ea) 800090: e8bfff17 ldw r2,-4(ea) /* * The other exception handling code goes here. */ .section .exceptions.unknown /* * If you get here then one of the following could have happened: * * - Your program could have been compiled for a full-featured Nios II * core, but it is running on a smaller core, and instruction emulation * has been disabled by defining ALT_NO_INSTRUCTION_EMULATION. * * You can work around the problem by re-enabling instruction emulation, * or you can figure out why your program is being compiled for a system * other than the one that it is running on. * * - Your program has executed a trap instruction, but has not implemented * a handler for this instruction. * * - Your program has executed an illegal instruction (one which is not * defined in the instruction set). * * - Your hardware is broken and is generating spurious interrupts (a * peripheral which deasserts its interrupt output before its interrupt * handler has been executed will cause spurious interrupts). * */ #ifdef NIOS2_HAS_DEBUG_STUB /* * Either tell the user now (if there is a debugger attached) or go into * the debug monitor which will loop until a debugger is attached. */ break 800094: 003da03a break 0 #else /* * If there is no debug stub then a BREAK will probably cause a reboot. * An infinate loop will probably be more useful. */ 0: br 0b #endif .section .exceptions.exit, "xa" /* * Restore the saved registers, so that all general purpose registers * have been restored to their state at the time the interrupt occured. */ ldw r5, 68(sp) 800098: d9401117 ldw r5,68(sp) ldw ea, 72(sp) 80009c: df401217 ldw ea,72(sp) ldw ra, 0(sp) 8000a0: dfc00017 ldw ra,0(sp) wrctl estatus, r5 8000a4: 2801707a wrctl estatus,r5 ldw r1, 8(sp) 8000a8: d8400217 ldw at,8(sp) ldw r2, 12(sp) 8000ac: d8800317 ldw r2,12(sp) ldw r3, 16(sp) 8000b0: d8c00417 ldw r3,16(sp) ldw r4, 20(sp) 8000b4: d9000517 ldw r4,20(sp) ldw r5, 24(sp) 8000b8: d9400617 ldw r5,24(sp) ldw r6, 28(sp) 8000bc: d9800717 ldw r6,28(sp) ldw r7, 32(sp) 8000c0: d9c00817 ldw r7,32(sp) #ifdef ALT_EXCEPTION_STACK #ifdef ALT_STACK_CHECK ldw et, %gprel(alt_exception_old_stack_limit)(gp) #endif #endif ldw r8, 36(sp) 8000c4: da000917 ldw r8,36(sp) ldw r9, 40(sp) 8000c8: da400a17 ldw r9,40(sp) ldw r10, 44(sp) 8000cc: da800b17 ldw r10,44(sp) ldw r11, 48(sp) 8000d0: dac00c17 ldw r11,48(sp) ldw r12, 52(sp) 8000d4: db000d17 ldw r12,52(sp) ldw r13, 56(sp) 8000d8: db400e17 ldw r13,56(sp) ldw r14, 60(sp) 8000dc: db800f17 ldw r14,60(sp) ldw r15, 64(sp) 8000e0: dbc01017 ldw r15,64(sp) #ifdef ALT_EXCEPTION_STACK #ifdef ALT_STACK_CHECK stw et, %gprel(alt_stack_limit_value)(gp) stw zero, %gprel(alt_exception_old_stack_limit)(gp) #endif ldw sp, 76(sp) #else addi sp, sp, 76 8000e4: dec01304 addi sp,sp,76 #endif /* * Return to the interrupted instruction. */ eret 8000e8: e800083a eret
008000ec <alt_irq_handler>: */ void alt_irq_handler (void) __attribute__ ((section (".exceptions"))); void alt_irq_handler (void) { 8000ec: defff904 addi sp,sp,-28 8000f0: dfc00615 stw ra,24(sp) 8000f4: df000515 stw fp,20(sp) 8000f8: d839883a mov fp,sp static ALT_INLINE alt_u32 ALT_ALWAYS_INLINE alt_irq_pending (void) { alt_u32 active; NIOS2_READ_IPENDING (active); 8000fc: 0005313a rdctl r2,ipending 800100: e0800415 stw r2,16(fp) 800104: e0800417 ldw r2,16(fp) 800108: e0800315 stw r2,12(fp) 80010c: e0800317 ldw r2,12(fp) 800110: e0800015 stw r2,0(fp) #ifdef ALT_CI_INTERRUPT_VECTOR alt_32 offset; char* alt_irq_base = (char*)alt_irq; #else alt_u32 active; alt_u32 mask; alt_u32 i; #endif /* ALT_CI_INTERRUPT_VECTOR */ /* * Notify the operating system that we are at interrupt level. */ ALT_OS_INT_ENTER(); #ifdef ALT_CI_INTERRUPT_VECTOR /* * Call the interrupt vector custom instruction using the * ALT_CI_INTERRUPT_VECTOR macro. * It returns the offset into the vector table of the lowest-valued pending * interrupt (corresponds to highest priority) or a negative value if none. * The custom instruction assumes that each table entry is eight bytes. */ while ((offset = ALT_CI_INTERRUPT_VECTOR) >= 0) { struct ALT_IRQ_HANDLER* handler_entry = (struct ALT_IRQ_HANDLER*)(alt_irq_base + offset); handler_entry->handler(handler_entry->context, offset >> 3); } #else /* * Obtain from the interrupt controller a bit list of pending interrupts, * and then process the highest priority interrupt. This process loops, * loading the active interrupt list on each pass until alt_irq_pending() * return zero. * * The maximum interrupt latency for the highest priority interrupt is * reduced by finding out which interrupts are pending as late as possible. * Consider the case where the high priority interupt is asserted during * the interrupt entry sequence for a lower priority interrupt to see why * this is the case. */ active = alt_irq_pending (); do { i = 0; 800114: e0000215 stw zero,8(fp) mask = 1; 800118: 00800044 movi r2,1 80011c: e0800115 stw r2,4(fp) /* * Test each bit in turn looking for an active interrupt. Once one is * found, the interrupt handler asigned by a call to alt_irq_register() is * called to clear the interrupt condition. */ do { if (active & mask) 800120: e0c00017 ldw r3,0(fp) 800124: e0800117 ldw r2,4(fp) 800128: 1884703a and r2,r3,r2 80012c: 1005003a cmpeq r2,r2,zero 800130: 1000101e bne r2,zero,800174 <alt_irq_handler+0x88> { alt_irq[i].handler(alt_irq[i].context, i); 800134: 00c02034 movhi r3,128 800138: 18d66e04 addi r3,r3,22968 80013c: e0800217 ldw r2,8(fp) 800140: 10800224 muli r2,r2,8 800144: 10c9883a add r4,r2,r3 800148: 00c02034 movhi r3,128 80014c: 18d66e04 addi r3,r3,22968 800150: e0800217 ldw r2,8(fp) 800154: 10800224 muli r2,r2,8 800158: 10c5883a add r2,r2,r3 80015c: 10800104 addi r2,r2,4 800160: 20c00017 ldw r3,0(r4) 800164: 11000017 ldw r4,0(r2) 800168: e1400217 ldw r5,8(fp) 80016c: 183ee83a callr r3 break; 800170: 00000706 br 800190 <alt_irq_handler+0xa4> } mask <<= 1; 800174: e0800117 ldw r2,4(fp) 800178: 1085883a add r2,r2,r2 80017c: e0800115 stw r2,4(fp) i++; 800180: e0800217 ldw r2,8(fp) 800184: 10800044 addi r2,r2,1 800188: e0800215 stw r2,8(fp) } while (1); 80018c: 003fe406 br 800120 <alt_irq_handler+0x34> static ALT_INLINE alt_u32 ALT_ALWAYS_INLINE alt_irq_pending (void) { alt_u32 active; NIOS2_READ_IPENDING (active); 800190: 0005313a rdctl r2,ipending 800194: e0800315 stw r2,12(fp) 800198: e0800317 ldw r2,12(fp) 80019c: e0800415 stw r2,16(fp) 8001a0: e0800417 ldw r2,16(fp) 8001a4: e0800015 stw r2,0(fp) active = alt_irq_pending (); } while (active); 8001a8: e0800017 ldw r2,0(fp) 8001ac: 1005003a cmpeq r2,r2,zero 8001b0: 1000011e bne r2,zero,8001b8 <alt_irq_handler+0xcc> 8001b4: 003fd706 br 800114 <alt_irq_handler+0x28> #endif /* ALT_CI_INTERRUPT_VECTOR */ /* * Notify the operating system that interrupt processing is complete. */ ALT_OS_INT_EXIT(); } 8001b8: dfc00617 ldw ra,24(sp) 8001bc: df000517 ldw fp,20(sp) 8001c0: dec00704 addi sp,sp,28 8001c4: f800283a ret
008001c8 <_start>: .size __reset, . - __reset #endif /* Jump to _start */ /* * When not using exit, provide an _exit symbol to prevent unresolved * references to _exit from the linker script. */ #ifdef ALT_NO_EXIT .globl _exit _exit: #endif /*************************************************************************\ | TEXT SECTION (.text) | \*************************************************************************/ /* * Start of the .text section, and also the code entry point when * the code is executed by a bootloader rather than directly from reset. */ .section .text .align 2 .globl _start .type _start, @function _start: /* * Initialize the data cache if present (i.e. size > 0) and not * optimizing for RTL simulation. * RTL simulations can ensure the data cache is already initialized * so skipping this loop speeds up RTL simulation. */ #if NIOS2_DCACHE_SIZE > 0 && !defined(ALT_SIM_OPTIMIZE) /* Assume the data cache size is always a power of two. */ #if NIOS2_DCACHE_SIZE > 0x8000 movhi r2, %hi(NIOS2_DCACHE_SIZE) #else movui r2, NIOS2_DCACHE_SIZE 8001c8: 00820014 movui r2,2048 #endif 0: initd 0(r2) 8001cc: 10000033 initd 0(r2) addi r2, r2, -NIOS2_DCACHE_LINE_SIZE 8001d0: 10bff804 addi r2,r2,-32 bgt r2, zero, 0b 8001d4: 00bffd16 blt zero,r2,8001cc <__ram_exceptions_end+0x4> 1: /* * The following debug information tells the ISS not to run the loop above * but to perform its actions using faster internal code. */ .pushsection .debug_alt_sim_info .int 2, 1, 0b, 1b .popsection #endif /* Initialize Data Cache */ /* Log that caches have been initialized. */ ALT_LOG_PUTS(alt_log_msg_cache) /* Log that the stack pointer is about to be setup. */ ALT_LOG_PUTS(alt_log_msg_stackpointer) /* * Now that the caches are initialized, set up the stack pointer. * The value provided by the linker is assumed to be correctly aligned. */ movhi sp, %hi(__alt_stack_pointer) 8001d8: 06c04034 movhi sp,256 ori sp, sp, %lo(__alt_stack_pointer) 8001dc: dec00014 ori sp,sp,0 /* Set up the global pointer. */ movhi gp, %hi(_gp) 8001e0: 06802034 movhi gp,128 ori gp, gp, %lo(_gp) 8001e4: d6b65214 ori gp,gp,55624 /* * Clear the BSS if not optimizing for RTL simulation. * * This uses the symbols: __bss_start and __bss_end, which are defined * by the linker script. They mark the begining and the end of the bss * region. The linker script guarantees that these values are word aligned. */ #ifndef ALT_SIM_OPTIMIZE /* Log that the BSS is about to be cleared. */ ALT_LOG_PUTS(alt_log_msg_bss) movhi r2, %hi(__bss_start) 8001e8: 00802034 movhi r2,128 ori r2, r2, %lo(__bss_start) 8001ec: 10966c14 ori r2,r2,22960 movhi r3, %hi(__bss_end) 8001f0: 00c02034 movhi r3,128 ori r3, r3, %lo(__bss_end) 8001f4: 18d6f114 ori r3,r3,23492 beq r2, r3, 1f 8001f8: 10c00326 beq r2,r3,800208 <__ram_exceptions_end+0x40> 0: stw zero, (r2) 8001fc: 10000015 stw zero,0(r2) addi r2, r2, 4 800200: 10800104 addi r2,r2,4 bltu r2, r3, 0b 800204: 10fffd36 bltu r2,r3,8001fc <__ram_exceptions_end+0x34> 1: /* * The following debug information tells the ISS not to run the loop above * but to perform its actions using faster internal code. */ .pushsection .debug_alt_sim_info .int 3, 1, 0b, 1b .popsection #endif /* ALT_SIM_OPTIMIZE */ /* * The alt_load() facility is normally used when there is no bootloader. * It copies some sections into RAM so it acts like a mini-bootloader. */ #ifdef CALL_ALT_LOAD #ifdef ALT_STACK_CHECK /* * If the user has selected stack checking then we need to set up a safe * value in the stack limit register so that the relocation functions * don't think the stack has overflowed (the contents of the rwdata * section aren't defined until alt_load() has been called). */ mov et, zero #endif call alt_load 800208: 08002e40 call 8002e4 <alt_load> #endif /* CALL_ALT_LOAD */ #ifdef ALT_STACK_CHECK /* * Set up the stack limit (if required). The linker has set up the * copy of the variable which is in memory. */ ldw et, %gprel(alt_stack_limit_value)(gp) #endif /* Log that alt_main is about to be called. */ ALT_LOG_PUTS(alt_log_msg_alt_main) /* Call the C entry point. It should never return. */ call alt_main 80020c: 08003c80 call 8003c8 <alt_main> 00800210 <alt_after_alt_main>: /* Wait in infinite loop in case alt_main does return. */ alt_after_alt_main: br alt_after_alt_main 800210: 003fff06 br 800210 <alt_after_alt_main>
See main2.c
00800214 <main>: int a = 14; int b = -8; int main() { 800214: defffd04 addi sp,sp,-12 800218: dfc00215 stw ra,8(sp) 80021c: df000115 stw fp,4(sp) 800220: d839883a mov fp,sp int c; c = sign(a,b); 800224: d1200017 ldw r4,-32768(gp) 800228: d1600117 ldw r5,-32764(gp) 80022c: 08002880 call 800288 <sign> 800230: e0800015 stw r2,0(fp) return 0; 800234: 0005883a mov r2,zero } 800238: dfc00217 ldw ra,8(sp) 80023c: df000117 ldw fp,4(sp) 800240: dec00304 addi sp,sp,12 800244: f800283a ret 00800248 <abs>: int abs(int a) { 800248: defffd04 addi sp,sp,-12 80024c: df000215 stw fp,8(sp) 800250: d839883a mov fp,sp 800254: e1000015 stw r4,0(fp) return (a<0? -a: a); 800258: e0800017 ldw r2,0(fp) 80025c: e0800115 stw r2,4(fp) 800260: e0800017 ldw r2,0(fp) 800264: 1004403a cmpge r2,r2,zero 800268: 1000031e bne r2,zero,800278 <abs+0x30> 80026c: e0800117 ldw r2,4(fp) 800270: 0085c83a sub r2,zero,r2 800274: e0800115 stw r2,4(fp) 800278: e0800117 ldw r2,4(fp) } 80027c: df000217 ldw fp,8(sp) 800280: dec00304 addi sp,sp,12 800284: f800283a ret 00800288 <sign>: int sign(int x, int y) { 800288: defffc04 addi sp,sp,-16 80028c: df000315 stw fp,12(sp) 800290: d839883a mov fp,sp 800294: e1000015 stw r4,0(fp) 800298: e1400115 stw r5,4(fp) return (y<0? -abs(x): abs(x)); 80029c: e0800017 ldw r2,0(fp) 8002a0: e0800215 stw r2,8(fp) 8002a4: e0c00217 ldw r3,8(fp) 8002a8: 1804403a cmpge r2,r3,zero 8002ac: 1000031e bne r2,zero,8002bc <sign+0x34> 8002b0: e0800217 ldw r2,8(fp) 8002b4: 0085c83a sub r2,zero,r2 8002b8: e0800215 stw r2,8(fp) 8002bc: e0800117 ldw r2,4(fp) 8002c0: 1004403a cmpge r2,r2,zero 8002c4: 1000031e bne r2,zero,8002d4 <sign+0x4c> 8002c8: e0c00217 ldw r3,8(fp) 8002cc: 00c7c83a sub r3,zero,r3 8002d0: e0c00215 stw r3,8(fp) 8002d4: e0800217 ldw r2,8(fp) } 8002d8: df000317 ldw fp,12(sp) 8002dc: dec00404 addi sp,sp,16 8002e0: f800283a ret
See alt_load.c
008002e4 <alt_load>: * RAM any sections that are required. */ void alt_load (void) { 8002e4: defffe04 addi sp,sp,-8 8002e8: dfc00115 stw ra,4(sp) 8002ec: df000015 stw fp,0(sp) 8002f0: d839883a mov fp,sp /* * Copy the .rwdata section. */ alt_load_section (&__flash_rwdata_start, 8002f4: 01002034 movhi r4,128 8002f8: 210f9d04 addi r4,r4,15988 8002fc: 01402034 movhi r5,128 800300: 294f9d04 addi r5,r5,15988 800304: 01802034 movhi r6,128 800308: 31966c04 addi r6,r6,22960 80030c: 08003600 call 800360 <alt_load_section> &__ram_rwdata_start, &__ram_rwdata_end); /* * Copy the exception handler. */ alt_load_section (&__flash_exceptions_start, 800310: 01002034 movhi r4,128 800314: 21000804 addi r4,r4,32 800318: 01402034 movhi r5,128 80031c: 29400804 addi r5,r5,32 800320: 01802034 movhi r6,128 800324: 31807204 addi r6,r6,456 800328: 08003600 call 800360 <alt_load_section> &__ram_exceptions_start, &__ram_exceptions_end); /* * Copy the .rodata section. */ alt_load_section (&__flash_rodata_start, 80032c: 01002034 movhi r4,128 800330: 210f2e04 addi r4,r4,15544 800334: 01402034 movhi r5,128 800338: 294f2e04 addi r5,r5,15544 80033c: 01802034 movhi r6,128 800340: 318f9d04 addi r6,r6,15988 800344: 08003600 call 800360 <alt_load_section> &__ram_rodata_start, &__ram_rodata_end); /* * Now ensure that the caches are in synch. */ alt_dcache_flush_all(); 800348: 0801e280 call 801e28 <alt_dcache_flush_all> alt_icache_flush_all(); 80034c: 08020380 call 802038 <alt_icache_flush_all> } 800350: dfc00117 ldw ra,4(sp) 800354: df000017 ldw fp,0(sp) 800358: dec00204 addi sp,sp,8 80035c: f800283a ret 00800360 <alt_load_section>: static void ALT_INLINE alt_load_section (alt_u32* from, alt_u32* to, alt_u32* end) { 800360: defffc04 addi sp,sp,-16 800364: df000315 stw fp,12(sp) 800368: d839883a mov fp,sp 80036c: e1000015 stw r4,0(fp) 800370: e1400115 stw r5,4(fp) 800374: e1800215 stw r6,8(fp) if (to != from) 800378: e0c00117 ldw r3,4(fp) 80037c: e0800017 ldw r2,0(fp) 800380: 18800e26 beq r3,r2,8003bc <alt_load_section+0x5c> { while( to != end ) 800384: e0c00117 ldw r3,4(fp) 800388: e0800217 ldw r2,8(fp) 80038c: 18800b26 beq r3,r2,8003bc <alt_load_section+0x5c> { *to++ = *from++; 800390: e1400104 addi r5,fp,4 800394: 28c00017 ldw r3,0(r5) 800398: e0800017 ldw r2,0(fp) 80039c: 11000017 ldw r4,0(r2) 8003a0: 10800104 addi r2,r2,4 8003a4: e0800015 stw r2,0(fp) 8003a8: 1805883a mov r2,r3 8003ac: 11000015 stw r4,0(r2) 8003b0: 18c00104 addi r3,r3,4 8003b4: 28c00015 stw r3,0(r5) 8003b8: 003ff206 br 800384 <alt_load_section+0x24> } } } 8003bc: df000317 ldw fp,12(sp) 8003c0: dec00404 addi sp,sp,16 8003c4: f800283a ret 008003c8 <alt_main>: * the users application, i.e. main(). */
See alt_main.c
void alt_main (void) { 8003c8: defffd04 addi sp,sp,-12 8003cc: dfc00215 stw ra,8(sp) 8003d0: df000115 stw fp,4(sp) 8003d4: d839883a mov fp,sp */ static ALT_INLINE void ALT_ALWAYS_INLINE alt_irq_init (const void* base) { 8003d8: e0000015 stw zero,0(fp) NIOS2_WRITE_IENABLE (0); 8003dc: 000170fa wrctl ienable,zero NIOS2_WRITE_STATUS (NIOS2_STATUS_PIE_MSK); 8003e0: 00800044 movi r2,1 8003e4: 1001703a wrctl status,r2 */ static ALT_INLINE int ALT_ALWAYS_INLINE alt_no_error (void) { return 0; 8003e8: e0000015 stw zero,0(fp) /* ALT LOG - please see HAL/sys/alt_log_printf.h for details */ ALT_LOG_PRINT_BOOT("[alt_main.c] Entering alt_main, calling alt_irq_init.\r\n"); /* Initialize the interrupt controller. */ alt_irq_init (ALT_IRQ_BASE); /* Initialize the operating system */ ALT_LOG_PRINT_BOOT("[alt_main.c] Done alt_irq_init, calling alt_os_init.\r\n"); ALT_OS_INIT(); /* * Initialize the semaphore used to control access to the file descriptor * list. */ ALT_LOG_PRINT_BOOT("[alt_main.c] Done OS Init, calling alt_sem_create.\r\n"); ALT_SEM_CREATE (&alt_fd_list_lock, 1); /* Initialize the device drivers/software components. */ ALT_LOG_PRINT_BOOT("[alt_main.c] Calling alt_sys_init.\r\n"); alt_sys_init(); 8003ec: 08004340 call 800434 <alt_sys_init> ALT_LOG_PRINT_BOOT("[alt_main.c] Done alt_sys_init.\r\n"); #if !defined(ALT_USE_DIRECT_DRIVERS) && (defined(ALT_STDIN_PRESENT) || defined(ALT_STDOUT_PRESENT) || defined(ALT_STDERR_PRESENT)) /* * Redirect stdio to the apropriate devices now that the devices have * been initialized. This is only done if the user has requested these * devices be present (not equal to /dev/null) and if direct drivers * aren't being used. */ ALT_LOG_PRINT_BOOT("[alt_main.c] Redirecting IO.\r\n"); alt_io_redirect(ALT_STDOUT, ALT_STDIN, ALT_STDERR); 8003f0: 01002034 movhi r4,128 8003f4: 210f2e04 addi r4,r4,15544 8003f8: 01402034 movhi r5,128 8003fc: 294f2e04 addi r5,r5,15544 800400: 01802034 movhi r6,128 800404: 318f2e04 addi r6,r6,15544 800408: 08021240 call 802124 <alt_io_redirect> #endif #ifndef ALT_NO_C_PLUS_PLUS /* * Call the C++ constructors */ ALT_LOG_PRINT_BOOT("[alt_main.c] Calling C++ constructors.\r\n"); _do_ctors (); 80040c: 0801f880 call 801f88 <_do_ctors> #endif /* ALT_NO_C_PLUS_PLUS */ #if !defined(ALT_NO_C_PLUS_PLUS) && !defined(ALT_NO_CLEAN_EXIT) && !defined(ALT_NO_EXIT) /* * Set the C++ destructors to be called at system shutdown. This is only done * if a clean exit has been requested (i.e. the exit() function has not been * redefined as _exit()). This is in the interest of reducing code footprint, * in that the atexit() overhead is removed when it's not needed. */ ALT_LOG_PRINT_BOOT("[alt_main.c] Calling atexit.\r\n"); atexit (_do_dtors); 800410: 01002034 movhi r4,128 800414: 2107f804 addi r4,r4,8160 800418: 0802bb40 call 802bb4 <atexit> #endif /* * Finally, call main(). The return code is then passed to a subsequent * call to exit() unless the application is never supposed to exit. */ ALT_LOG_PRINT_BOOT("[alt_main.c] Calling main.\r\n"); #ifdef ALT_NO_EXIT main (alt_argc, alt_argv, alt_envp); #else exit (main (alt_argc, alt_argv, alt_envp)); 80041c: d1200217 ldw r4,-32760(gp) 800420: d1600317 ldw r5,-32756(gp) 800424: d1a00417 ldw r6,-32752(gp) 800428: 08002140 call 800214 <main> 80042c: 1009883a mov r4,r2 800430: 0802c500 call 802c50 <exit> 00800434 <alt_sys_init>: 800434: defffe04 addi sp,sp,-8 800438: dfc00115 stw ra,4(sp) 80043c: df000015 stw fp,0(sp) 800440: d839883a mov fp,sp 800444: 01004034 movhi r4,256 800448: 21040004 addi r4,r4,4096 80044c: 000b883a mov r5,zero 800450: 0180fa04 movi r6,1000 800454: 0801c600 call 801c60 <alt_avalon_timer_sc_init> 800458: 01002034 movhi r4,128 80045c: 210fa704 addi r4,r4,16028 800460: 01400044 movi r5,1 800464: 08005c00 call 8005c0 <altera_avalon_jtag_uart_init> 800468: 01002034 movhi r4,128 80046c: 210f9d04 addi r4,r4,15988 800470: 080049c0 call 80049c <alt_dev_reg> 800474: 01002034 movhi r4,128 800478: 2113bf04 addi r4,r4,20220 80047c: 0801aac0 call 801aac <altera_avalon_lcd_16207_init> 800480: 01002034 movhi r4,128 800484: 2113b504 addi r4,r4,20180 800488: 080049c0 call 80049c <alt_dev_reg> 80048c: dfc00117 ldw ra,4(sp) 800490: df000017 ldw fp,0(sp) 800494: dec00204 addi sp,sp,8 800498: f800283a ret 0080049c <alt_dev_reg>: extern int alt_fs_reg (alt_dev* dev); static ALT_INLINE int alt_dev_reg (alt_dev* dev) { 80049c: defffd04 addi sp,sp,-12 8004a0: dfc00215 stw ra,8(sp) 8004a4: df000115 stw fp,4(sp) 8004a8: d839883a mov fp,sp 8004ac: e1000015 stw r4,0(fp) extern alt_llist alt_dev_list; return alt_dev_llist_insert ((alt_dev_llist*) dev, &alt_dev_list); 8004b0: e1000017 ldw r4,0(fp) 8004b4: d1600804 addi r5,gp,-32736 8004b8: 0801e900 call 801e90 <alt_dev_llist_insert> } 8004bc: dfc00217 ldw ra,8(sp) 8004c0: df000117 ldw fp,4(sp) 8004c4: dec00304 addi sp,sp,12 8004c8: f800283a ret 008004cc <altera_avalon_jtag_uart_read_fd>: */ int altera_avalon_jtag_uart_read_fd(alt_fd* fd, char* buffer, int space) { 8004cc: defffa04 addi sp,sp,-24 8004d0: dfc00515 stw ra,20(sp) 8004d4: df000415 stw fp,16(sp) 8004d8: d839883a mov fp,sp 8004dc: e1000015 stw r4,0(fp) 8004e0: e1400115 stw r5,4(fp) 8004e4: e1800215 stw r6,8(fp) altera_avalon_jtag_uart_dev* dev = (altera_avalon_jtag_uart_dev*) fd->dev; 8004e8: e0800017 ldw r2,0(fp) 8004ec: 10800017 ldw r2,0(r2) 8004f0: e0800315 stw r2,12(fp) return altera_avalon_jtag_uart_read(&dev->state, buffer, space, 8004f4: e0800317 ldw r2,12(fp) 8004f8: 11000a04 addi r4,r2,40 8004fc: e0800017 ldw r2,0(fp) 800500: e1400117 ldw r5,4(fp) 800504: e1800217 ldw r6,8(fp) 800508: 11c00217 ldw r7,8(r2) 80050c: 0800a480 call 800a48 <altera_avalon_jtag_uart_read> fd->fd_flags); } 800510: dfc00517 ldw ra,20(sp) 800514: df000417 ldw fp,16(sp) 800518: dec00604 addi sp,sp,24 80051c: f800283a ret 00800520 <altera_avalon_jtag_uart_write_fd>: int altera_avalon_jtag_uart_write_fd(alt_fd* fd, const char* buffer, int space) { 800520: defffa04 addi sp,sp,-24 800524: dfc00515 stw ra,20(sp) 800528: df000415 stw fp,16(sp) 80052c: d839883a mov fp,sp 800530: e1000015 stw r4,0(fp) 800534: e1400115 stw r5,4(fp) 800538: e1800215 stw r6,8(fp) altera_avalon_jtag_uart_dev* dev = (altera_avalon_jtag_uart_dev*) fd->dev; 80053c: e0800017 ldw r2,0(fp) 800540: 10800017 ldw r2,0(r2) 800544: e0800315 stw r2,12(fp) return altera_avalon_jtag_uart_write(&dev->state, buffer, space, 800548: e0800317 ldw r2,12(fp) 80054c: 11000a04 addi r4,r2,40 800550: e0800017 ldw r2,0(fp) 800554: e1400117 ldw r5,4(fp) 800558: e1800217 ldw r6,8(fp) 80055c: 11c00217 ldw r7,8(r2) 800560: 0800c780 call 800c78 <altera_avalon_jtag_uart_write> fd->fd_flags); } 800564: dfc00517 ldw ra,20(sp) 800568: df000417 ldw fp,16(sp) 80056c: dec00604 addi sp,sp,24 800570: f800283a ret 00800574 <altera_avalon_jtag_uart_ioctl_fd>: #ifndef ALTERA_AVALON_JTAG_UART_SMALL int altera_avalon_jtag_uart_ioctl_fd(alt_fd* fd, int req, void* arg) { 800574: defffa04 addi sp,sp,-24 800578: dfc00515 stw ra,20(sp) 80057c: df000415 stw fp,16(sp) 800580: d839883a mov fp,sp 800584: e1000015 stw r4,0(fp) 800588: e1400115 stw r5,4(fp) 80058c: e1800215 stw r6,8(fp) altera_avalon_jtag_uart_dev* dev = (altera_avalon_jtag_uart_dev*) fd->dev; 800590: e0800017 ldw r2,0(fp) 800594: 10800017 ldw r2,0(r2) 800598: e0800315 stw r2,12(fp) return altera_avalon_jtag_uart_ioctl(&dev->state, req, arg); 80059c: e0800317 ldw r2,12(fp) 8005a0: 11000a04 addi r4,r2,40 8005a4: e1400117 ldw r5,4(fp) 8005a8: e1800217 ldw r6,8(fp) 8005ac: 08009500 call 800950 <altera_avalon_jtag_uart_ioctl> } 8005b0: dfc00517 ldw ra,20(sp) 8005b4: df000417 ldw fp,16(sp) 8005b8: dec00604 addi sp,sp,24 8005bc: f800283a ret 008005c0 <altera_avalon_jtag_uart_init>: */ void altera_avalon_jtag_uart_init(altera_avalon_jtag_uart_state* sp, int irq) { 8005c0: defff804 addi sp,sp,-32 8005c4: dfc00715 stw ra,28(sp) 8005c8: df000615 stw fp,24(sp) 8005cc: d839883a mov fp,sp 8005d0: e1000015 stw r4,0(fp) 8005d4: e1400115 stw r5,4(fp) */ static ALT_INLINE int ALT_ALWAYS_INLINE alt_no_error (void) { return 0; 8005d8: e0000215 stw zero,8(fp) 8005dc: e0000315 stw zero,12(fp) 8005e0: e0000415 stw zero,16(fp) ALT_FLAG_CREATE(&sp->events, 0); ALT_SEM_CREATE(&sp->read_lock, 1); ALT_SEM_CREATE(&sp->write_lock, 1); /* enable read interrupts at the device */ sp->irq_enable = ALTERA_AVALON_JTAG_UART_CONTROL_RE_MSK; 8005e4: e0c00017 ldw r3,0(fp) 8005e8: 00800044 movi r2,1 8005ec: 18800815 stw r2,32(r3) IOWR_ALTERA_AVALON_JTAG_UART_CONTROL(sp->base, sp->irq_enable); 8005f0: e0800017 ldw r2,0(fp) 8005f4: 10800017 ldw r2,0(r2) 8005f8: 10800104 addi r2,r2,4 8005fc: 1007883a mov r3,r2 800600: e0800017 ldw r2,0(fp) 800604: 10800817 ldw r2,32(r2) 800608: 18800035 stwio r2,0(r3) /* register the interrupt handler */ alt_irq_register(irq, sp, altera_avalon_jtag_uart_irq); 80060c: e1000117 ldw r4,4(fp) 800610: e1400017 ldw r5,0(fp) 800614: 01802034 movhi r6,128 800618: 31819d04 addi r6,r6,1652 80061c: 08021980 call 802198 <alt_irq_register> /* Register an alarm to go off every second to check for presence of host */ sp->host_inactive = 0; 800620: e0800017 ldw r2,0(fp) 800624: 10000915 stw zero,36(r2) */ static ALT_INLINE alt_u32 ALT_ALWAYS_INLINE alt_ticks_per_second (void) { return _alt_tick_rate; 800628: d0a00e17 ldw r2,-32712(gp) 80062c: e0800515 stw r2,20(fp) 800630: e1400517 ldw r5,20(fp) 800634: e0800017 ldw r2,0(fp) 800638: 11000204 addi r4,r2,8 80063c: 01802034 movhi r6,128 800640: 31822304 addi r6,r6,2188 800644: e1c00017 ldw r7,0(fp) 800648: 0801ce00 call 801ce0 <alt_alarm_start> 80064c: 1004403a cmpge r2,r2,zero 800650: 1000041e bne r2,zero,800664 <altera_avalon_jtag_uart_init+0xa4> if (alt_alarm_start(&sp->alarm, alt_ticks_per_second(), &altera_avalon_jtag_uart_timeout, sp) < 0) { /* If we can't set the alarm then record "don't know if host present" * and behave as though the host is present. */ sp->timeout = INT_MAX; 800654: e0c00017 ldw r3,0(fp) 800658: 00a00034 movhi r2,32768 80065c: 10bfffc4 addi r2,r2,-1 800660: 18800115 stw r2,4(r3) } /* ALT_LOG - see altera_hal/HAL/inc/sys/alt_log_printf.h */ ALT_LOG_JTAG_UART_ALARM_REGISTER(sp, sp->base); } 800664: dfc00717 ldw ra,28(sp) 800668: df000617 ldw fp,24(sp) 80066c: dec00804 addi sp,sp,32 800670: f800283a ret 00800674 <altera_avalon_jtag_uart_irq>: /* * Interrupt routine */ static void altera_avalon_jtag_uart_irq(void* context, alt_u32 id) { 800674: defff704 addi sp,sp,-36 800678: df000815 stw fp,32(sp) 80067c: d839883a mov fp,sp 800680: e1000015 stw r4,0(fp) 800684: e1400115 stw r5,4(fp) altera_avalon_jtag_uart_state* sp = (altera_avalon_jtag_uart_state*) context; 800688: e0800017 ldw r2,0(fp) 80068c: e0800215 stw r2,8(fp) unsigned int base = sp->base; 800690: e0800217 ldw r2,8(fp) 800694: 10800017 ldw r2,0(r2) 800698: e0800315 stw r2,12(fp) /* ALT_LOG - see altera_hal/HAL/inc/sys/alt_log_printf.h */ ALT_LOG_JTAG_UART_ISR_FUNCTION(base, sp); for ( ; ; ) { unsigned int control = IORD_ALTERA_AVALON_JTAG_UART_CONTROL(base); 80069c: e0800317 ldw r2,12(fp) 8006a0: 10800104 addi r2,r2,4 8006a4: 10800037 ldwio r2,0(r2) 8006a8: e0800415 stw r2,16(fp) /* Return once nothing more to do */ if ((control & (ALTERA_AVALON_JTAG_UART_CONTROL_RI_MSK | ALTERA_AVALON_JTAG_UART_CONTROL_WI_MSK)) == 0) 8006ac: e0800417 ldw r2,16(fp) 8006b0: 1080c00c andi r2,r2,768 8006b4: 1004c03a cmpne r2,r2,zero 8006b8: 1000011e bne r2,zero,8006c0 <altera_avalon_jtag_uart_irq+0x4c> break; 8006bc: 00007006 br 800880 <altera_avalon_jtag_uart_irq+0x20c> if (control & ALTERA_AVALON_JTAG_UART_CONTROL_RI_MSK) 8006c0: e0800417 ldw r2,16(fp) 8006c4: 1004d23a srli r2,r2,8 8006c8: 1080004c andi r2,r2,1 8006cc: 1005003a cmpeq r2,r2,zero 8006d0: 1000361e bne r2,zero,8007ac <altera_avalon_jtag_uart_irq+0x138> { /* process a read irq. Start by assuming that there is data in the * receive FIFO (otherwise why would we have been interrupted?) */ unsigned int data = 1 << ALTERA_AVALON_JTAG_UART_DATA_RAVAIL_OFST; 8006d4: 00800074 movhi r2,1 8006d8: 10800004 addi r2,r2,0 8006dc: e0800515 stw r2,20(fp) for ( ; ; ) { /* Check whether there is space in the buffer. If not then we must not * read any characters from the buffer as they will be lost. */ unsigned int next = (sp->rx_in + 1) % ALTERA_AVALON_JTAG_UART_BUF_LEN; 8006e0: e0800217 ldw r2,8(fp) 8006e4: 10800a17 ldw r2,40(r2) 8006e8: 10800044 addi r2,r2,1 8006ec: 1081ffcc andi r2,r2,2047 8006f0: e0800615 stw r2,24(fp) if (next == sp->rx_out) 8006f4: e0800217 ldw r2,8(fp) 8006f8: 10c00b17 ldw r3,44(r2) 8006fc: e0800617 ldw r2,24(fp) 800700: 1880011e bne r3,r2,800708 <altera_avalon_jtag_uart_irq+0x94> break; 800704: 00001906 br 80076c <altera_avalon_jtag_uart_irq+0xf8> /* Try to remove a character from the FIFO and find out whether there * are any more characters remaining. */ data = IORD_ALTERA_AVALON_JTAG_UART_DATA(base); 800708: e0800317 ldw r2,12(fp) 80070c: 10800037 ldwio r2,0(r2) 800710: e0800515 stw r2,20(fp) if ((data & ALTERA_AVALON_JTAG_UART_DATA_RVALID_MSK) == 0) 800714: e0800517 ldw r2,20(fp) 800718: 1004d3fa srli r2,r2,15 80071c: 1080005c xori r2,r2,1 800720: 1080004c andi r2,r2,1 800724: 1005003a cmpeq r2,r2,zero 800728: 1000011e bne r2,zero,800730 <altera_avalon_jtag_uart_irq+0xbc> break; 80072c: 00000f06 br 80076c <altera_avalon_jtag_uart_irq+0xf8> sp->rx_buf[sp->rx_in] = (data & ALTERA_AVALON_JTAG_UART_DATA_DATA_MSK) >> ALTERA_AVALON_JTAG_UART_DATA_DATA_OFST; 800730: e0c00217 ldw r3,8(fp) 800734: e0800217 ldw r2,8(fp) 800738: 10800a17 ldw r2,40(r2) 80073c: 1885883a add r2,r3,r2 800740: 10c00e04 addi r3,r2,56 800744: e0800517 ldw r2,20(fp) 800748: 18800005 stb r2,0(r3) sp->rx_in = (sp->rx_in + 1) % ALTERA_AVALON_JTAG_UART_BUF_LEN; 80074c: e0c00217 ldw r3,8(fp) 800750: e0800217 ldw r2,8(fp) 800754: 10800a17 ldw r2,40(r2) 800758: 10800044 addi r2,r2,1 80075c: 1081ffcc andi r2,r2,2047 800760: 18800a15 stw r2,40(r3) */ static ALT_INLINE int ALT_ALWAYS_INLINE alt_no_error (void) { return 0; 800764: e0000715 stw zero,28(fp) 800768: 003fdd06 br 8006e0 <altera_avalon_jtag_uart_irq+0x6c> /* Post an event to notify jtag_uart_read that a character has been read */ ALT_FLAG_POST (sp->events, ALT_JTAG_UART_READ_RDY, OS_FLAG_SET); } if (data & ALTERA_AVALON_JTAG_UART_DATA_RAVAIL_MSK) 80076c: e0800517 ldw r2,20(fp) 800770: 10bfffec andhi r2,r2,65535 800774: 1005003a cmpeq r2,r2,zero 800778: 10000c1e bne r2,zero,8007ac <altera_avalon_jtag_uart_irq+0x138> { /* If there is still data available here then the buffer is full * so turn off receive interrupts until some space becomes available. */ sp->irq_enable &= ~ALTERA_AVALON_JTAG_UART_CONTROL_RE_MSK; 80077c: e1000217 ldw r4,8(fp) 800780: e0800217 ldw r2,8(fp) 800784: 10c00817 ldw r3,32(r2) 800788: 00bfff84 movi r2,-2 80078c: 1884703a and r2,r3,r2 800790: 20800815 stw r2,32(r4) IOWR_ALTERA_AVALON_JTAG_UART_CONTROL(base, sp->irq_enable); 800794: e0800317 ldw r2,12(fp) 800798: 10800104 addi r2,r2,4 80079c: 1007883a mov r3,r2 8007a0: e0800217 ldw r2,8(fp) 8007a4: 10800817 ldw r2,32(r2) 8007a8: 18800035 stwio r2,0(r3) } } if (control & ALTERA_AVALON_JTAG_UART_CONTROL_WI_MSK) 8007ac: e0800417 ldw r2,16(fp) 8007b0: 1004d27a srli r2,r2,9 8007b4: 1080004c andi r2,r2,1 8007b8: 1005003a cmpeq r2,r2,zero 8007bc: 103fb71e bne r2,zero,80069c <altera_avalon_jtag_uart_irq+0x28> { /* process a write irq */ unsigned int space = (control & ALTERA_AVALON_JTAG_UART_CONTROL_WSPACE_MSK) >> ALTERA_AVALON_JTAG_UART_CONTROL_WSPACE_OFST; 8007c0: e0800417 ldw r2,16(fp) 8007c4: 10bfffec andhi r2,r2,65535 8007c8: 1004d43a srli r2,r2,16 8007cc: e0800715 stw r2,28(fp) while (space > 0 && sp->tx_out != sp->tx_in) 8007d0: e0800717 ldw r2,28(fp) 8007d4: 1005003a cmpeq r2,r2,zero 8007d8: 1000181e bne r2,zero,80083c <altera_avalon_jtag_uart_irq+0x1c8> 8007dc: e0800217 ldw r2,8(fp) 8007e0: e0c00217 ldw r3,8(fp) 8007e4: 11000d17 ldw r4,52(r2) 8007e8: 18800c17 ldw r2,48(r3) 8007ec: 20801326 beq r4,r2,80083c <altera_avalon_jtag_uart_irq+0x1c8> { IOWR_ALTERA_AVALON_JTAG_UART_DATA(base, sp->tx_buf[sp->tx_out]); 8007f0: e1000317 ldw r4,12(fp) 8007f4: e0c00217 ldw r3,8(fp) 8007f8: e0800217 ldw r2,8(fp) 8007fc: 10800d17 ldw r2,52(r2) 800800: 1885883a add r2,r3,r2 800804: 10820e04 addi r2,r2,2104 800808: 10800007 ldb r2,0(r2) 80080c: 20800035 stwio r2,0(r4) sp->tx_out = (sp->tx_out + 1) % ALTERA_AVALON_JTAG_UART_BUF_LEN; 800810: e0c00217 ldw r3,8(fp) 800814: e0800217 ldw r2,8(fp) 800818: 10800d17 ldw r2,52(r2) 80081c: 10800044 addi r2,r2,1 800820: 1081ffcc andi r2,r2,2047 800824: 18800d15 stw r2,52(r3) */ static ALT_INLINE int ALT_ALWAYS_INLINE alt_no_error (void) { return 0; 800828: e0000615 stw zero,24(fp) /* Post an event to notify jtag_uart_write that a character has been written */ ALT_FLAG_POST (sp->events, ALT_JTAG_UART_WRITE_RDY, OS_FLAG_SET); space--; 80082c: e0800717 ldw r2,28(fp) 800830: 10bfffc4 addi r2,r2,-1 800834: e0800715 stw r2,28(fp) 800838: 003fe506 br 8007d0 <altera_avalon_jtag_uart_irq+0x15c> } if (space > 0) 80083c: e0800717 ldw r2,28(fp) 800840: 1005003a cmpeq r2,r2,zero 800844: 103f951e bne r2,zero,80069c <altera_avalon_jtag_uart_irq+0x28> { /* If we don't have any more data available then turn off the TX interrupt */ sp->irq_enable &= ~ALTERA_AVALON_JTAG_UART_CONTROL_WE_MSK; 800848: e1000217 ldw r4,8(fp) 80084c: e0800217 ldw r2,8(fp) 800850: 10c00817 ldw r3,32(r2) 800854: 00bfff44 movi r2,-3 800858: 1884703a and r2,r3,r2 80085c: 20800815 stw r2,32(r4) IOWR_ALTERA_AVALON_JTAG_UART_CONTROL(sp->base, sp->irq_enable); 800860: e0800217 ldw r2,8(fp) 800864: 10800017 ldw r2,0(r2) 800868: 10800104 addi r2,r2,4 80086c: 1007883a mov r3,r2 800870: e0800217 ldw r2,8(fp) 800874: 10800817 ldw r2,32(r2) 800878: 18800035 stwio r2,0(r3) 80087c: 003f8706 br 80069c <altera_avalon_jtag_uart_irq+0x28> } } } } 800880: df000817 ldw fp,32(sp) 800884: dec00904 addi sp,sp,36 800888: f800283a ret 0080088c <altera_avalon_jtag_uart_timeout>: /* * Timeout routine is called every second */ static alt_u32 altera_avalon_jtag_uart_timeout(void* context) { 80088c: defffb04 addi sp,sp,-20 800890: df000415 stw fp,16(sp) 800894: d839883a mov fp,sp 800898: e1000015 stw r4,0(fp) altera_avalon_jtag_uart_state* sp = (altera_avalon_jtag_uart_state *) context; 80089c: e0800017 ldw r2,0(fp) 8008a0: e0800115 stw r2,4(fp) unsigned int control = IORD_ALTERA_AVALON_JTAG_UART_CONTROL(sp->base); 8008a4: e0800117 ldw r2,4(fp) 8008a8: 10800017 ldw r2,0(r2) 8008ac: 10800104 addi r2,r2,4 8008b0: 10800037 ldwio r2,0(r2) 8008b4: e0800215 stw r2,8(fp) if (control & ALTERA_AVALON_JTAG_UART_CONTROL_AC_MSK) 8008b8: e0800217 ldw r2,8(fp) 8008bc: 1004d2ba srli r2,r2,10 8008c0: 1080004c andi r2,r2,1 8008c4: 1005003a cmpeq r2,r2,zero 8008c8: 10000b1e bne r2,zero,8008f8 <altera_avalon_jtag_uart_timeout+0x6c> { IOWR_ALTERA_AVALON_JTAG_UART_CONTROL(sp->base, sp->irq_enable | ALTERA_AVALON_JTAG_UART_CONTROL_AC_MSK); 8008cc: e0800117 ldw r2,4(fp) 8008d0: 10800017 ldw r2,0(r2) 8008d4: 10800104 addi r2,r2,4 8008d8: 1007883a mov r3,r2 8008dc: e0800117 ldw r2,4(fp) 8008e0: 10800817 ldw r2,32(r2) 8008e4: 10810014 ori r2,r2,1024 8008e8: 18800035 stwio r2,0(r3) sp->host_inactive = 0; 8008ec: e0800117 ldw r2,4(fp) 8008f0: 10000915 stw zero,36(r2) 8008f4: 00001006 br 800938 <altera_avalon_jtag_uart_timeout+0xac> } else if (sp->host_inactive < INT_MAX - 2) { 8008f8: e0800117 ldw r2,4(fp) 8008fc: 10c00917 ldw r3,36(r2) 800900: 00a00034 movhi r2,32768 800904: 10bfff04 addi r2,r2,-4 800908: 10c00b36 bltu r2,r3,800938 <altera_avalon_jtag_uart_timeout+0xac> sp->host_inactive++; 80090c: e0c00117 ldw r3,4(fp) 800910: e0800117 ldw r2,4(fp) 800914: 10800917 ldw r2,36(r2) 800918: 10800044 addi r2,r2,1 80091c: 18800915 stw r2,36(r3) if (sp->host_inactive >= sp->timeout) { 800920: e0800117 ldw r2,4(fp) 800924: e0c00117 ldw r3,4(fp) 800928: 11000917 ldw r4,36(r2) 80092c: 18800117 ldw r2,4(r3) 800930: 20800136 bltu r4,r2,800938 <altera_avalon_jtag_uart_timeout+0xac> */ static ALT_INLINE int ALT_ALWAYS_INLINE alt_no_error (void) { return 0; 800934: e0000315 stw zero,12(fp) */ static ALT_INLINE alt_u32 ALT_ALWAYS_INLINE alt_ticks_per_second (void) { return _alt_tick_rate; 800938: d0a00e17 ldw r2,-32712(gp) 80093c: e0800315 stw r2,12(fp) 800940: e0800317 ldw r2,12(fp) /* Post an event to indicate host is inactive (for jtag_uart_read */ ALT_FLAG_POST (sp->events, ALT_JTAG_UART_TIMEOUT, OS_FLAG_SET); } } return alt_ticks_per_second(); } 800944: df000417 ldw fp,16(sp) 800948: dec00504 addi sp,sp,20 80094c: f800283a ret 00800950 <altera_avalon_jtag_uart_ioctl>: int altera_avalon_jtag_uart_ioctl(altera_avalon_jtag_uart_state* sp, int req, void* arg) { 800950: defff704 addi sp,sp,-36 800954: df000815 stw fp,32(sp) 800958: d839883a mov fp,sp 80095c: e1000015 stw r4,0(fp) 800960: e1400115 stw r5,4(fp) 800964: e1800215 stw r6,8(fp) int rc = -ENOTTY; 800968: 00bff9c4 movi r2,-25 80096c: e0800315 stw r2,12(fp) switch (req) 800970: e0800117 ldw r2,4(fp) 800974: e0800715 stw r2,28(fp) 800978: e0c00717 ldw r3,28(fp) 80097c: 189a8060 cmpeqi r2,r3,27137 800980: 1000041e bne r2,zero,800994 <altera_avalon_jtag_uart_ioctl+0x44> 800984: e0c00717 ldw r3,28(fp) 800988: 189a80a0 cmpeqi r2,r3,27138 80098c: 10001d1e bne r2,zero,800a04 <altera_avalon_jtag_uart_ioctl+0xb4> 800990: 00002906 br 800a38 <altera_avalon_jtag_uart_ioctl+0xe8> { case TIOCSTIMEOUT: /* Set the time to wait until assuming host is not connected */ if (sp->timeout != INT_MAX) 800994: e0800017 ldw r2,0(fp) 800998: 10c00117 ldw r3,4(r2) 80099c: 00a00034 movhi r2,32768 8009a0: 10bfffc4 addi r2,r2,-1 8009a4: 18802426 beq r3,r2,800a38 <altera_avalon_jtag_uart_ioctl+0xe8> { int timeout = *((int *)arg); 8009a8: e0800217 ldw r2,8(fp) 8009ac: 10800017 ldw r2,0(r2) 8009b0: e0800415 stw r2,16(fp) sp->timeout = (timeout >= 2 && timeout < INT_MAX) ? timeout : INT_MAX - 1; 8009b4: e0800017 ldw r2,0(fp) 8009b8: e0800515 stw r2,20(fp) 8009bc: e0800417 ldw r2,16(fp) 8009c0: 10800090 cmplti r2,r2,2 8009c4: 1000071e bne r2,zero,8009e4 <altera_avalon_jtag_uart_ioctl+0x94> 8009c8: e0c00417 ldw r3,16(fp) 8009cc: 00a00034 movhi r2,32768 8009d0: 10bfffc4 addi r2,r2,-1 8009d4: 18800326 beq r3,r2,8009e4 <altera_avalon_jtag_uart_ioctl+0x94> 8009d8: e0c00417 ldw r3,16(fp) 8009dc: e0c00615 stw r3,24(fp) 8009e0: 00000306 br 8009f0 <altera_avalon_jtag_uart_ioctl+0xa0> 8009e4: 00a00034 movhi r2,32768 8009e8: 10bfff84 addi r2,r2,-2 8009ec: e0800615 stw r2,24(fp) 8009f0: e0c00617 ldw r3,24(fp) 8009f4: e0800517 ldw r2,20(fp) 8009f8: 10c00115 stw r3,4(r2) rc = 0; 8009fc: e0000315 stw zero,12(fp) } break; 800a00: 00000d06 br 800a38 <altera_avalon_jtag_uart_ioctl+0xe8> case TIOCGCONNECTED: /* Find out whether host is connected */ if (sp->timeout != INT_MAX) 800a04: e0800017 ldw r2,0(fp) 800a08: 10c00117 ldw r3,4(r2) 800a0c: 00a00034 movhi r2,32768 800a10: 10bfffc4 addi r2,r2,-1 800a14: 18800826 beq r3,r2,800a38 <altera_avalon_jtag_uart_ioctl+0xe8> { *((int *)arg) = (sp->host_inactive < sp->timeout) ? 1 : 0; 800a18: e1400217 ldw r5,8(fp) 800a1c: e0800017 ldw r2,0(fp) 800a20: e0c00017 ldw r3,0(fp) 800a24: 11000917 ldw r4,36(r2) 800a28: 18800117 ldw r2,4(r3) 800a2c: 2085803a cmpltu r2,r4,r2 800a30: 28800015 stw r2,0(r5) rc = 0; 800a34: e0000315 stw zero,12(fp) } break; default: break; } return rc; 800a38: e0800317 ldw r2,12(fp) } 800a3c: df000817 ldw fp,32(sp) 800a40: dec00904 addi sp,sp,36 800a44: f800283a ret 00800a48 <altera_avalon_jtag_uart_read>: int altera_avalon_jtag_uart_read(altera_avalon_jtag_uart_state* sp, char * buffer, int space, int flags) { 800a48: defff204 addi sp,sp,-56 800a4c: dfc00d15 stw ra,52(sp) 800a50: df000c15 stw fp,48(sp) 800a54: d839883a mov fp,sp 800a58: e1000015 stw r4,0(fp) 800a5c: e1400115 stw r5,4(fp) 800a60: e1800215 stw r6,8(fp) 800a64: e1c00315 stw r7,12(fp) char * ptr = buffer; 800a68: e0800117 ldw r2,4(fp) 800a6c: e0800415 stw r2,16(fp) */ static ALT_INLINE int ALT_ALWAYS_INLINE alt_no_error (void) { return 0; 800a70: e0000715 stw zero,28(fp) alt_irq_context context; unsigned int n; /* * When running in a multi threaded environment, obtain the "read_lock" * semaphore. This ensures that reading from the device is thread-safe. */ ALT_SEM_PEND (sp->read_lock, 0); while (space > 0) 800a74: e0800217 ldw r2,8(fp) 800a78: 10800050 cmplti r2,r2,1 800a7c: 10004c1e bne r2,zero,800bb0 <altera_avalon_jtag_uart_read+0x168> { unsigned int in, out; /* Read as much data as possible */ do { in = sp->rx_in; 800a80: e0800017 ldw r2,0(fp) 800a84: 10800a17 ldw r2,40(r2) 800a88: e0800815 stw r2,32(fp) out = sp->rx_out; 800a8c: e0800017 ldw r2,0(fp) 800a90: 10800b17 ldw r2,44(r2) 800a94: e0800915 stw r2,36(fp) if (in >= out) 800a98: e0c00817 ldw r3,32(fp) 800a9c: e0800917 ldw r2,36(fp) 800aa0: 18800536 bltu r3,r2,800ab8 <altera_avalon_jtag_uart_read+0x70> n = in - out; 800aa4: e0800817 ldw r2,32(fp) 800aa8: e0c00917 ldw r3,36(fp) 800aac: 10c5c83a sub r2,r2,r3 800ab0: e0800615 stw r2,24(fp) 800ab4: 00000406 br 800ac8 <altera_avalon_jtag_uart_read+0x80> else n = ALTERA_AVALON_JTAG_UART_BUF_LEN - out; 800ab8: 00820004 movi r2,2048 800abc: e0c00917 ldw r3,36(fp) 800ac0: 10c5c83a sub r2,r2,r3 800ac4: e0800615 stw r2,24(fp) if (n == 0) 800ac8: e0800617 ldw r2,24(fp) 800acc: 1004c03a cmpne r2,r2,zero 800ad0: 1000011e bne r2,zero,800ad8 <altera_avalon_jtag_uart_read+0x90> break; /* No more data available */ 800ad4: 00001e06 br 800b50 <altera_avalon_jtag_uart_read+0x108> if (n > space) 800ad8: e0c00217 ldw r3,8(fp) 800adc: e0800617 ldw r2,24(fp) 800ae0: 1880022e bgeu r3,r2,800aec <altera_avalon_jtag_uart_read+0xa4> n = space; 800ae4: e0800217 ldw r2,8(fp) 800ae8: e0800615 stw r2,24(fp) memcpy(ptr, sp->rx_buf + out, n); 800aec: e0c00017 ldw r3,0(fp) 800af0: e0800917 ldw r2,36(fp) 800af4: 1885883a add r2,r3,r2 800af8: 11400e04 addi r5,r2,56 800afc: e1000417 ldw r4,16(fp) 800b00: e1800617 ldw r6,24(fp) 800b04: 08034840 call 803484 <memcpy> ptr += n; 800b08: e0c00417 ldw r3,16(fp) 800b0c: e0800617 ldw r2,24(fp) 800b10: 1885883a add r2,r3,r2 800b14: e0800415 stw r2,16(fp) space -= n; 800b18: e0c00217 ldw r3,8(fp) 800b1c: e0800617 ldw r2,24(fp) 800b20: 1885c83a sub r2,r3,r2 800b24: e0800215 stw r2,8(fp) sp->rx_out = (out + n) % ALTERA_AVALON_JTAG_UART_BUF_LEN; 800b28: e1000017 ldw r4,0(fp) 800b2c: e0c00917 ldw r3,36(fp) 800b30: e0800617 ldw r2,24(fp) 800b34: 1885883a add r2,r3,r2 800b38: 1081ffcc andi r2,r2,2047 800b3c: 20800b15 stw r2,44(r4) } 800b40: e0800217 ldw r2,8(fp) 800b44: 10800050 cmplti r2,r2,1 800b48: 1000011e bne r2,zero,800b50 <altera_avalon_jtag_uart_read+0x108> 800b4c: 003fcc06 br 800a80 <altera_avalon_jtag_uart_read+0x38> while (space > 0); /* If we read any data then return it */ if (ptr != buffer) 800b50: e0c00417 ldw r3,16(fp) 800b54: e0800117 ldw r2,4(fp) 800b58: 18800126 beq r3,r2,800b60 <altera_avalon_jtag_uart_read+0x118> break; 800b5c: 00001406 br 800bb0 <altera_avalon_jtag_uart_read+0x168> /* If in non-blocking mode then return error */ if (flags & O_NONBLOCK) 800b60: e0800317 ldw r2,12(fp) 800b64: 1004d3ba srli r2,r2,14 800b68: 1080004c andi r2,r2,1 800b6c: 1005003a cmpeq r2,r2,zero 800b70: 1000011e bne r2,zero,800b78 <altera_avalon_jtag_uart_read+0x130> break; 800b74: 00000e06 br 800bb0 <altera_avalon_jtag_uart_read+0x168> #ifdef __ucosii__ /* OS Present: Pend on a flag if the OS is running, otherwise spin */ if(OSRunning == OS_TRUE) { /* * When running in a multi-threaded mode, we pend on the read event * flag set and timeout event flag set in the isr. This avoids wasting CPU * cycles waiting in this thread, when we could be doing something more * profitable elsewhere. */ ALT_FLAG_PEND (sp->events, ALT_JTAG_UART_READ_RDY | ALT_JTAG_UART_TIMEOUT, OS_FLAG_WAIT_SET_ANY + OS_FLAG_CONSUME, 0); } else { /* Spin until more data arrives or until host disconnects */ while (in == sp->rx_in && sp->host_inactive < sp->timeout) ; } #else /* No OS: Always spin */ while (in == sp->rx_in && sp->host_inactive < sp->timeout) 800b78: e0800017 ldw r2,0(fp) 800b7c: 10c00a17 ldw r3,40(r2) 800b80: e0800817 ldw r2,32(fp) 800b84: 1880061e bne r3,r2,800ba0 <altera_avalon_jtag_uart_read+0x158> 800b88: e0800017 ldw r2,0(fp) 800b8c: e0c00017 ldw r3,0(fp) 800b90: 11000917 ldw r4,36(r2) 800b94: 18800117 ldw r2,4(r3) 800b98: 2080012e bgeu r4,r2,800ba0 <altera_avalon_jtag_uart_read+0x158> 800b9c: 003ff606 br 800b78 <altera_avalon_jtag_uart_read+0x130> ; #endif /* __ucosii__ */ if (in == sp->rx_in) 800ba0: e0800017 ldw r2,0(fp) 800ba4: 10c00a17 ldw r3,40(r2) 800ba8: e0800817 ldw r2,32(fp) 800bac: 18bfb11e bne r3,r2,800a74 <altera_avalon_jtag_uart_read+0x2c> */ static ALT_INLINE int ALT_ALWAYS_INLINE alt_no_error (void) { return 0; 800bb0: e0000915 stw zero,36(fp) break; } /* * Now that access to the circular buffer is complete, release the read * semaphore so that other threads can access the buffer. */ ALT_SEM_POST (sp->read_lock); if (ptr != buffer) 800bb4: e0c00417 ldw r3,16(fp) 800bb8: e0800117 ldw r2,4(fp) 800bbc: 18801726 beq r3,r2,800c1c <altera_avalon_jtag_uart_read+0x1d4> alt_irq_disable_all (void) { alt_irq_context context; NIOS2_READ_STATUS (context); 800bc0: 0005303a rdctl r2,status 800bc4: e0800a15 stw r2,40(fp) NIOS2_WRITE_STATUS (0); 800bc8: 0001703a wrctl status,zero 800bcc: e0800a17 ldw r2,40(fp) 800bd0: e0800815 stw r2,32(fp) 800bd4: e0800817 ldw r2,32(fp) 800bd8: e0800515 stw r2,20(fp) { /* If we read any data then there is space in the buffer so enable interrupts */ context = alt_irq_disable_all(); sp->irq_enable |= ALTERA_AVALON_JTAG_UART_CONTROL_RE_MSK; 800bdc: e0c00017 ldw r3,0(fp) 800be0: e0800017 ldw r2,0(fp) 800be4: 10800817 ldw r2,32(r2) 800be8: 10800054 ori r2,r2,1 800bec: 18800815 stw r2,32(r3) IOWR_ALTERA_AVALON_JTAG_UART_CONTROL(sp->base, sp->irq_enable); 800bf0: e0800017 ldw r2,0(fp) 800bf4: 10800017 ldw r2,0(r2) 800bf8: 10800104 addi r2,r2,4 800bfc: 1007883a mov r3,r2 800c00: e0800017 ldw r2,0(fp) 800c04: 10800817 ldw r2,32(r2) 800c08: 18800035 stwio r2,0(r3) */ static ALT_INLINE void ALT_ALWAYS_INLINE alt_irq_enable_all (alt_irq_context context) { 800c0c: e0800517 ldw r2,20(fp) 800c10: e0800a15 stw r2,40(fp) NIOS2_WRITE_STATUS (context); 800c14: e0800a17 ldw r2,40(fp) 800c18: 1001703a wrctl status,r2 alt_irq_enable_all(context); } if (ptr != buffer) 800c1c: e0c00417 ldw r3,16(fp) 800c20: e0800117 ldw r2,4(fp) 800c24: 18800526 beq r3,r2,800c3c <altera_avalon_jtag_uart_read+0x1f4> return ptr - buffer; 800c28: e0800417 ldw r2,16(fp) 800c2c: e0c00117 ldw r3,4(fp) 800c30: 10c5c83a sub r2,r2,r3 800c34: e0800b15 stw r2,44(fp) 800c38: 00000a06 br 800c64 <altera_avalon_jtag_uart_read+0x21c> else if (flags & O_NONBLOCK) 800c3c: e0800317 ldw r2,12(fp) 800c40: 1004d3ba srli r2,r2,14 800c44: 1080004c andi r2,r2,1 800c48: 1005003a cmpeq r2,r2,zero 800c4c: 1000031e bne r2,zero,800c5c <altera_avalon_jtag_uart_read+0x214> return -EWOULDBLOCK; 800c50: 00bffd44 movi r2,-11 800c54: e0800b15 stw r2,44(fp) 800c58: 00000206 br 800c64 <altera_avalon_jtag_uart_read+0x21c> else return -EIO; 800c5c: 00bffec4 movi r2,-5 800c60: e0800b15 stw r2,44(fp) } 800c64: e0800b17 ldw r2,44(fp) 800c68: dfc00d17 ldw ra,52(sp) 800c6c: df000c17 ldw fp,48(sp) 800c70: dec00e04 addi sp,sp,56 800c74: f800283a ret 00800c78 <altera_avalon_jtag_uart_write>: int altera_avalon_jtag_uart_write(altera_avalon_jtag_uart_state* sp, const char * ptr, int count, int flags) { 800c78: defff104 addi sp,sp,-60 800c7c: dfc00e15 stw ra,56(sp) 800c80: df000d15 stw fp,52(sp) 800c84: d839883a mov fp,sp 800c88: e1000015 stw r4,0(fp) 800c8c: e1400115 stw r5,4(fp) 800c90: e1800215 stw r6,8(fp) 800c94: e1c00315 stw r7,12(fp) /* Remove warning at optimisation level 03 by seting out to 0 */ unsigned int in, out=0; 800c98: e0000515 stw zero,20(fp) unsigned int n; alt_irq_context context; const char * start = ptr; 800c9c: e0800117 ldw r2,4(fp) 800ca0: e0800815 stw r2,32(fp) */ static ALT_INLINE int ALT_ALWAYS_INLINE alt_no_error (void) { return 0; 800ca4: e0000915 stw zero,36(fp) /* * When running in a multi threaded environment, obtain the "write_lock" * semaphore. This ensures that writing to the device is thread-safe. */ ALT_SEM_PEND (sp->write_lock, 0); do { /* Copy as much as we can into the transmit buffer */ while (count > 0) 800ca8: e0800217 ldw r2,8(fp) 800cac: 10800050 cmplti r2,r2,1 800cb0: 10003a1e bne r2,zero,800d9c <altera_avalon_jtag_uart_write+0x124> { /* We need a stable value of the out pointer to calculate the space available */ in = sp->tx_in; 800cb4: e0800017 ldw r2,0(fp) 800cb8: 10800c17 ldw r2,48(r2) 800cbc: e0800415 stw r2,16(fp) out = sp->tx_out; 800cc0: e0800017 ldw r2,0(fp) 800cc4: 10800d17 ldw r2,52(r2) 800cc8: e0800515 stw r2,20(fp) if (in < out) 800ccc: e0c00417 ldw r3,16(fp) 800cd0: e0800517 ldw r2,20(fp) 800cd4: 1880062e bgeu r3,r2,800cf0 <altera_avalon_jtag_uart_write+0x78> n = out - 1 - in; 800cd8: e0c00517 ldw r3,20(fp) 800cdc: e0800417 ldw r2,16(fp) 800ce0: 1885c83a sub r2,r3,r2 800ce4: 10bfffc4 addi r2,r2,-1 800ce8: e0800615 stw r2,24(fp) 800cec: 00000c06 br 800d20 <altera_avalon_jtag_uart_write+0xa8> else if (out > 0) 800cf0: e0800517 ldw r2,20(fp) 800cf4: 1005003a cmpeq r2,r2,zero 800cf8: 1000051e bne r2,zero,800d10 <altera_avalon_jtag_uart_write+0x98> n = ALTERA_AVALON_JTAG_UART_BUF_LEN - in; 800cfc: 00820004 movi r2,2048 800d00: e0c00417 ldw r3,16(fp) 800d04: 10c5c83a sub r2,r2,r3 800d08: e0800615 stw r2,24(fp) 800d0c: 00000406 br 800d20 <altera_avalon_jtag_uart_write+0xa8> else n = ALTERA_AVALON_JTAG_UART_BUF_LEN - 1 - in; 800d10: 0081ffc4 movi r2,2047 800d14: e0c00417 ldw r3,16(fp) 800d18: 10c5c83a sub r2,r2,r3 800d1c: e0800615 stw r2,24(fp) if (n == 0) 800d20: e0800617 ldw r2,24(fp) 800d24: 1004c03a cmpne r2,r2,zero 800d28: 1000011e bne r2,zero,800d30 <altera_avalon_jtag_uart_write+0xb8> break; 800d2c: 00001b06 br 800d9c <altera_avalon_jtag_uart_write+0x124> if (n > count) 800d30: e0c00217 ldw r3,8(fp) 800d34: e0800617 ldw r2,24(fp) 800d38: 1880022e bgeu r3,r2,800d44 <altera_avalon_jtag_uart_write+0xcc> n = count; 800d3c: e0800217 ldw r2,8(fp) 800d40: e0800615 stw r2,24(fp) memcpy(sp->tx_buf + in, ptr, n); 800d44: e0c00017 ldw r3,0(fp) 800d48: e0800417 ldw r2,16(fp) 800d4c: 1885883a add r2,r3,r2 800d50: 11020e04 addi r4,r2,2104 800d54: e1400117 ldw r5,4(fp) 800d58: e1800617 ldw r6,24(fp) 800d5c: 08034840 call 803484 <memcpy> ptr += n; 800d60: e0c00117 ldw r3,4(fp) 800d64: e0800617 ldw r2,24(fp) 800d68: 1885883a add r2,r3,r2 800d6c: e0800115 stw r2,4(fp) count -= n; 800d70: e0c00217 ldw r3,8(fp) 800d74: e0800617 ldw r2,24(fp) 800d78: 1885c83a sub r2,r3,r2 800d7c: e0800215 stw r2,8(fp) sp->tx_in = (in + n) % ALTERA_AVALON_JTAG_UART_BUF_LEN; 800d80: e1000017 ldw r4,0(fp) 800d84: e0c00417 ldw r3,16(fp) 800d88: e0800617 ldw r2,24(fp) 800d8c: 1885883a add r2,r3,r2 800d90: 1081ffcc andi r2,r2,2047 800d94: 20800c15 stw r2,48(r4) 800d98: 003fc306 br 800ca8 <altera_avalon_jtag_uart_write+0x30> alt_irq_disable_all (void) { alt_irq_context context; NIOS2_READ_STATUS (context); 800d9c: 0005303a rdctl r2,status 800da0: e0800b15 stw r2,44(fp) NIOS2_WRITE_STATUS (0); 800da4: 0001703a wrctl status,zero 800da8: e0800b17 ldw r2,44(fp) 800dac: e0800a15 stw r2,40(fp) 800db0: e0800a17 ldw r2,40(fp) 800db4: e0800715 stw r2,28(fp) } /* * TODO: if interrupts are disabled then we could transmit here, we only need to enable * interrupts if there is no space left in the FIFO */ /* For now kick the interrupt routine every time to make it transmit the data */ context = alt_irq_disable_all(); sp->irq_enable |= ALTERA_AVALON_JTAG_UART_CONTROL_WE_MSK; 800db8: e0c00017 ldw r3,0(fp) 800dbc: e0800017 ldw r2,0(fp) 800dc0: 10800817 ldw r2,32(r2) 800dc4: 10800094 ori r2,r2,2 800dc8: 18800815 stw r2,32(r3) IOWR_ALTERA_AVALON_JTAG_UART_CONTROL(sp->base, sp->irq_enable); 800dcc: e0800017 ldw r2,0(fp) 800dd0: 10800017 ldw r2,0(r2) 800dd4: 10800104 addi r2,r2,4 800dd8: 1007883a mov r3,r2 800ddc: e0800017 ldw r2,0(fp) 800de0: 10800817 ldw r2,32(r2) 800de4: 18800035 stwio r2,0(r3) */ static ALT_INLINE void ALT_ALWAYS_INLINE alt_irq_enable_all (alt_irq_context context) { 800de8: e0800717 ldw r2,28(fp) 800dec: e0800b15 stw r2,44(fp) NIOS2_WRITE_STATUS (context); 800df0: e0800b17 ldw r2,44(fp) 800df4: 1001703a wrctl status,r2 alt_irq_enable_all(context); /* If there is any data left then either return now or block until some has been sent */ /* TODO: test whether there is anything there while doing this and delay for at most 2s. */ if (count > 0) 800df8: e0800217 ldw r2,8(fp) 800dfc: 10800050 cmplti r2,r2,1 800e00: 1000151e bne r2,zero,800e58 <altera_avalon_jtag_uart_write+0x1e0> { if (flags & O_NONBLOCK) 800e04: e0800317 ldw r2,12(fp) 800e08: 1004d3ba srli r2,r2,14 800e0c: 1080004c andi r2,r2,1 800e10: 1005003a cmpeq r2,r2,zero 800e14: 1000011e bne r2,zero,800e1c <altera_avalon_jtag_uart_write+0x1a4> break; 800e18: 00001306 br 800e68 <altera_avalon_jtag_uart_write+0x1f0> #ifdef __ucosii__ /* OS Present: Pend on a flag if the OS is running, otherwise spin */ if(OSRunning == OS_TRUE) { /* * When running in a multi-threaded mode, we pend on the write event * flag set or the timeout flag in the isr. This avoids wasting CPU * cycles waiting in this thread, when we could be doing something * more profitable elsewhere. */ ALT_FLAG_PEND (sp->events, ALT_JTAG_UART_WRITE_RDY | ALT_JTAG_UART_TIMEOUT, OS_FLAG_WAIT_SET_ANY + OS_FLAG_CONSUME, 0); } else { /* * OS not running: Wait for data to be removed from buffer. * Once the interrupt routine has removed some data then we * will be able to insert some more. */ while (out == sp->tx_out && sp->host_inactive < sp->timeout) ; } #else /* * No OS present: Always wait for data to be removed from buffer. Once * the interrupt routine has removed some data then we will be able to * insert some more. */ while (out == sp->tx_out && sp->host_inactive < sp->timeout) 800e1c: e0800017 ldw r2,0(fp) 800e20: 10c00d17 ldw r3,52(r2) 800e24: e0800517 ldw r2,20(fp) 800e28: 1880061e bne r3,r2,800e44 <altera_avalon_jtag_uart_write+0x1cc> 800e2c: e0800017 ldw r2,0(fp) 800e30: e0c00017 ldw r3,0(fp) 800e34: 11000917 ldw r4,36(r2) 800e38: 18800117 ldw r2,4(r3) 800e3c: 2080012e bgeu r4,r2,800e44 <altera_avalon_jtag_uart_write+0x1cc> 800e40: 003ff606 br 800e1c <altera_avalon_jtag_uart_write+0x1a4> ; #endif /* __ucosii__ */ if (out == sp->tx_out) 800e44: e0800017 ldw r2,0(fp) 800e48: 10c00d17 ldw r3,52(r2) 800e4c: e0800517 ldw r2,20(fp) 800e50: 1880011e bne r3,r2,800e58 <altera_avalon_jtag_uart_write+0x1e0> break; 800e54: 00000406 br 800e68 <altera_avalon_jtag_uart_write+0x1f0> } } 800e58: e0800217 ldw r2,8(fp) 800e5c: 10800050 cmplti r2,r2,1 800e60: 1000011e bne r2,zero,800e68 <altera_avalon_jtag_uart_write+0x1f0> 800e64: 003f9006 br 800ca8 <altera_avalon_jtag_uart_write+0x30> */ static ALT_INLINE int ALT_ALWAYS_INLINE alt_no_error (void) { return 0; 800e68: e0000b15 stw zero,44(fp) while (count > 0); /* * Now that access to the circular buffer is complete, release the write * semaphore so that other threads can access the buffer. */ ALT_SEM_POST (sp->write_lock); if (ptr != start) 800e6c: e0c00117 ldw r3,4(fp) 800e70: e0800817 ldw r2,32(fp) 800e74: 18800526 beq r3,r2,800e8c <altera_avalon_jtag_uart_write+0x214> return ptr - start; 800e78: e0800117 ldw r2,4(fp) 800e7c: e0c00817 ldw r3,32(fp) 800e80: 10c5c83a sub r2,r2,r3 800e84: e0800c15 stw r2,48(fp) 800e88: 00000a06 br 800eb4 <altera_avalon_jtag_uart_write+0x23c> else if (flags & O_NONBLOCK) 800e8c: e0800317 ldw r2,12(fp) 800e90: 1004d3ba srli r2,r2,14 800e94: 1080004c andi r2,r2,1 800e98: 1005003a cmpeq r2,r2,zero 800e9c: 1000031e bne r2,zero,800eac <altera_avalon_jtag_uart_write+0x234> return -EWOULDBLOCK; 800ea0: 00bffd44 movi r2,-11 800ea4: e0800c15 stw r2,48(fp) 800ea8: 00000206 br 800eb4 <altera_avalon_jtag_uart_write+0x23c> else return -EIO; /* Host not connected */ 800eac: 00bffec4 movi r2,-5 800eb0: e0800c15 stw r2,48(fp) } 800eb4: e0800c17 ldw r2,48(fp) 800eb8: dfc00e17 ldw ra,56(sp) 800ebc: df000d17 ldw fp,52(sp) 800ec0: dec00f04 addi sp,sp,60 800ec4: f800283a ret 00800ec8 <lcd_write_command>: /* --------------------------------------------------------------------- */ static void lcd_write_command(altera_avalon_lcd_16207_state* sp, unsigned char command) { 800ec8: defffa04 addi sp,sp,-24 800ecc: dfc00515 stw ra,20(sp) 800ed0: df000415 stw fp,16(sp) 800ed4: d839883a mov fp,sp 800ed8: e1000015 stw r4,0(fp) 800edc: e1400105 stb r5,4(fp) unsigned int base = sp->base; 800ee0: e0800017 ldw r2,0(fp) 800ee4: 10800017 ldw r2,0(r2) 800ee8: e0800215 stw r2,8(fp) /* We impose a timeout on the driver in case the LCD panel isn't connected. * The first time we call this function the timeout is approx 25ms * (assuming 5 cycles per loop and a 200MHz clock). Obviously systems * with slower clocks, or debug builds, or slower memory will take longer. */ int i = 1000000; 800eec: 008003f4 movhi r2,15 800ef0: 10909004 addi r2,r2,16960 800ef4: e0800315 stw r2,12(fp) /* Don't bother if the LCD panel didn't work before */ if (sp->broken) 800ef8: e0800017 ldw r2,0(fp) 800efc: 10800807 ldb r2,32(r2) 800f00: 1005003a cmpeq r2,r2,zero 800f04: 1000011e bne r2,zero,800f0c <lcd_write_command+0x44> return; 800f08: 00001506 br 800f60 <lcd_write_command+0x98> /* Wait until LCD isn't busy. */ while (IORD_ALTERA_AVALON_LCD_16207_STATUS(base) & ALTERA_AVALON_LCD_16207_STATUS_BUSY_MSK) 800f0c: e0800217 ldw r2,8(fp) 800f10: 10800104 addi r2,r2,4 800f14: 10800037 ldwio r2,0(r2) 800f18: 1004d1fa srli r2,r2,7 800f1c: 1080004c andi r2,r2,1 800f20: 1005003a cmpeq r2,r2,zero 800f24: 1000091e bne r2,zero,800f4c <lcd_write_command+0x84> if (--i == 0) 800f28: e0800317 ldw r2,12(fp) 800f2c: 10bfffc4 addi r2,r2,-1 800f30: e0800315 stw r2,12(fp) 800f34: 1004c03a cmpne r2,r2,zero 800f38: 103ff41e bne r2,zero,800f0c <lcd_write_command+0x44> { sp->broken = 1; 800f3c: e0c00017 ldw r3,0(fp) 800f40: 00800044 movi r2,1 800f44: 18800805 stb r2,32(r3) return; 800f48: 00000506 br 800f60 <lcd_write_command+0x98> } /* Despite what it says in the datasheet, the LCD isn't ready to accept * a write immediately after it returns BUSY=0. Wait for 100us more. */ usleep(100); 800f4c: 01001904 movi r4,100 800f50: 08027940 call 802794 <usleep> IOWR_ALTERA_AVALON_LCD_16207_COMMAND(base, command); 800f54: e0c00217 ldw r3,8(fp) 800f58: e0800103 ldbu r2,4(fp) 800f5c: 18800035 stwio r2,0(r3) } 800f60: dfc00517 ldw ra,20(sp) 800f64: df000417 ldw fp,16(sp) 800f68: dec00604 addi sp,sp,24 800f6c: f800283a ret 00800f70 <lcd_write_data>: /* --------------------------------------------------------------------- */ static void lcd_write_data(altera_avalon_lcd_16207_state* sp, unsigned char data) { 800f70: defffa04 addi sp,sp,-24 800f74: dfc00515 stw ra,20(sp) 800f78: df000415 stw fp,16(sp) 800f7c: d839883a mov fp,sp 800f80: e1000015 stw r4,0(fp) 800f84: e1400105 stb r5,4(fp) unsigned int base = sp->base; 800f88: e0800017 ldw r2,0(fp) 800f8c: 10800017 ldw r2,0(r2) 800f90: e0800215 stw r2,8(fp) /* We impose a timeout on the driver in case the LCD panel isn't connected. * The first time we call this function the timeout is approx 25ms * (assuming 5 cycles per loop and a 200MHz clock). Obviously systems * with slower clocks, or debug builds, or slower memory will take longer. */ int i = 1000000; 800f94: 008003f4 movhi r2,15 800f98: 10909004 addi r2,r2,16960 800f9c: e0800315 stw r2,12(fp) /* Don't bother if the LCD panel didn't work before */ if (sp->broken) 800fa0: e0800017 ldw r2,0(fp) 800fa4: 10800807 ldb r2,32(r2) 800fa8: 1005003a cmpeq r2,r2,zero 800fac: 1000011e bne r2,zero,800fb4 <lcd_write_data+0x44> return; 800fb0: 00001c06 br 801024 <lcd_write_data+0xb4> /* Wait until LCD isn't busy. */ while (IORD_ALTERA_AVALON_LCD_16207_STATUS(base) & ALTERA_AVALON_LCD_16207_STATUS_BUSY_MSK) 800fb4: e0800217 ldw r2,8(fp) 800fb8: 10800104 addi r2,r2,4 800fbc: 10800037 ldwio r2,0(r2) 800fc0: 1004d1fa srli r2,r2,7 800fc4: 1080004c andi r2,r2,1 800fc8: 1005003a cmpeq r2,r2,zero 800fcc: 1000091e bne r2,zero,800ff4 <lcd_write_data+0x84> if (--i == 0) 800fd0: e0800317 ldw r2,12(fp) 800fd4: 10bfffc4 addi r2,r2,-1 800fd8: e0800315 stw r2,12(fp) 800fdc: 1004c03a cmpne r2,r2,zero 800fe0: 103ff41e bne r2,zero,800fb4 <lcd_write_data+0x44> { sp->broken = 1; 800fe4: e0c00017 ldw r3,0(fp) 800fe8: 00800044 movi r2,1 800fec: 18800805 stb r2,32(r3) return; 800ff0: 00000c06 br 801024 <lcd_write_data+0xb4> } /* Despite what it says in the datasheet, the LCD isn't ready to accept * a write immediately after it returns BUSY=0. Wait for 100us more. */ usleep(100); 800ff4: 01001904 movi r4,100 800ff8: 08027940 call 802794 <usleep> IOWR_ALTERA_AVALON_LCD_16207_DATA(base, data); 800ffc: e0800217 ldw r2,8(fp) 801000: 10800204 addi r2,r2,8 801004: 1007883a mov r3,r2 801008: e0800103 ldbu r2,4(fp) 80100c: 18800035 stwio r2,0(r3) sp->address++; 801010: e0c00017 ldw r3,0(fp) 801014: e0800017 ldw r2,0(fp) 801018: 108008c3 ldbu r2,35(r2) 80101c: 10800044 addi r2,r2,1 801020: 188008c5 stb r2,35(r3) } 801024: dfc00517 ldw ra,20(sp) 801028: df000417 ldw fp,16(sp) 80102c: dec00604 addi sp,sp,24 801030: f800283a ret 00801034 <lcd_clear_screen>: /* --------------------------------------------------------------------- */ static void lcd_clear_screen(altera_avalon_lcd_16207_state* sp) { 801034: defffc04 addi sp,sp,-16 801038: dfc00315 stw ra,12(sp) 80103c: df000215 stw fp,8(sp) 801040: d839883a mov fp,sp 801044: e1000015 stw r4,0(fp) int y; lcd_write_command(sp, LCD_CMD_CLEAR); 801048: e1000017 ldw r4,0(fp) 80104c: 01400044 movi r5,1 801050: 0800ec80 call 800ec8 <lcd_write_command> sp->x = 0; 801054: e0800017 ldw r2,0(fp) 801058: 10000845 stb zero,33(r2) sp->y = 0; 80105c: e0800017 ldw r2,0(fp) 801060: 10000885 stb zero,34(r2) sp->address = 0; 801064: e0800017 ldw r2,0(fp) 801068: 100008c5 stb zero,35(r2) for (y = 0 ; y < ALT_LCD_HEIGHT ; y++) 80106c: e0000115 stw zero,4(fp) 801070: e0800117 ldw r2,4(fp) 801074: 10800088 cmpgei r2,r2,2 801078: 10001a1e bne r2,zero,8010e4 <lcd_clear_screen+0xb0> { memset(sp->line[y].data, ' ', sizeof(sp->line[0].data)); 80107c: e0800117 ldw r2,4(fp) 801080: 10c018e4 muli r3,r2,99 801084: e0800017 ldw r2,0(fp) 801088: 1885883a add r2,r3,r2 80108c: 11001004 addi r4,r2,64 801090: 01400804 movi r5,32 801094: 01801444 movi r6,81 801098: 08035400 call 803540 <memset> memset(sp->line[y].visible, ' ', sizeof(sp->line[0].visible)); 80109c: e0800117 ldw r2,4(fp) 8010a0: 10c018e4 muli r3,r2,99 8010a4: e0800017 ldw r2,0(fp) 8010a8: 1885883a add r2,r3,r2 8010ac: 11000c04 addi r4,r2,48 8010b0: 01400804 movi r5,32 8010b4: 01800404 movi r6,16 8010b8: 08035400 call 803540 <memset> sp->line[y].width = 0; 8010bc: e0c00017 ldw r3,0(fp) 8010c0: e0800117 ldw r2,4(fp) 8010c4: 108018e4 muli r2,r2,99 8010c8: 10c5883a add r2,r2,r3 8010cc: 10802404 addi r2,r2,144 8010d0: 10000045 stb zero,1(r2) 8010d4: e0800117 ldw r2,4(fp) 8010d8: 10800044 addi r2,r2,1 8010dc: e0800115 stw r2,4(fp) 8010e0: 003fe306 br 801070 <lcd_clear_screen+0x3c> } } 8010e4: dfc00317 ldw ra,12(sp) 8010e8: df000217 ldw fp,8(sp) 8010ec: dec00404 addi sp,sp,16 8010f0: f800283a ret 008010f4 <lcd_repaint_screen>: /* --------------------------------------------------------------------- */ static void lcd_repaint_screen(altera_avalon_lcd_16207_state* sp) { 8010f4: defff604 addi sp,sp,-40 8010f8: dfc00915 stw ra,36(sp) 8010fc: df000815 stw fp,32(sp) 801100: dc000715 stw r16,28(sp) 801104: d839883a mov fp,sp 801108: e1000015 stw r4,0(fp) int y, x; /* scrollpos controls how much the lines have scrolled round. The speed * each line scrolls at is controlled by its speed variable - while * scrolline lines will wrap at the position set by width */ int scrollpos = sp->scrollpos; 80110c: e0800017 ldw r2,0(fp) 801110: 10800947 ldb r2,37(r2) 801114: e0800315 stw r2,12(fp) for (y = 0 ; y < ALT_LCD_HEIGHT ; y++) 801118: e0000115 stw zero,4(fp) 80111c: e0800117 ldw r2,4(fp) 801120: 10800088 cmpgei r2,r2,2 801124: 10005a1e bne r2,zero,801290 <lcd_repaint_screen+0x19c> { int width = sp->line[y].width; 801128: e0c00017 ldw r3,0(fp) 80112c: e0800117 ldw r2,4(fp) 801130: 108018e4 muli r2,r2,99 801134: 10c5883a add r2,r2,r3 801138: 10802404 addi r2,r2,144 80113c: 10800047 ldb r2,1(r2) 801140: e0800415 stw r2,16(fp) int offset = (scrollpos * sp->line[y].speed) >> 8; 801144: e0c00017 ldw r3,0(fp) 801148: e0800117 ldw r2,4(fp) 80114c: 108018e4 muli r2,r2,99 801150: 10c5883a add r2,r2,r3 801154: 10802404 addi r2,r2,144 801158: 10c00083 ldbu r3,2(r2) 80115c: e0800317 ldw r2,12(fp) 801160: 1885383a mul r2,r3,r2 801164: 1005d23a srai r2,r2,8 801168: e0800515 stw r2,20(fp) if (offset >= width) 80116c: e0c00517 ldw r3,20(fp) 801170: e0800417 ldw r2,16(fp) 801174: 18800116 blt r3,r2,80117c <lcd_repaint_screen+0x88> offset = 0; 801178: e0000515 stw zero,20(fp) for (x = 0 ; x < ALT_LCD_WIDTH ; x++) 80117c: e0000215 stw zero,8(fp) 801180: e0800217 ldw r2,8(fp) 801184: 10800408 cmpgei r2,r2,16 801188: 10003d1e bne r2,zero,801280 <lcd_repaint_screen+0x18c> { char c = sp->line[y].data[(x + offset) % width]; 80118c: e4000017 ldw r16,0(fp) 801190: e0c00217 ldw r3,8(fp) 801194: e0800517 ldw r2,20(fp) 801198: 1889883a add r4,r3,r2 80119c: e1400417 ldw r5,16(fp) 8011a0: 0803b100 call 803b10 <__modsi3> 8011a4: 1007883a mov r3,r2 8011a8: e0800117 ldw r2,4(fp) 8011ac: 108018e4 muli r2,r2,99 8011b0: 1405883a add r2,r2,r16 8011b4: 10c5883a add r2,r2,r3 8011b8: 10801004 addi r2,r2,64 8011bc: 10800003 ldbu r2,0(r2) 8011c0: e0800605 stb r2,24(fp) /* Writing data takes 40us, so don't do it unless required */ if (sp->line[y].visible[x] != c) 8011c4: e0c00017 ldw r3,0(fp) 8011c8: e0800117 ldw r2,4(fp) 8011cc: 108018e4 muli r2,r2,99 8011d0: 10c7883a add r3,r2,r3 8011d4: e0800217 ldw r2,8(fp) 8011d8: 1885883a add r2,r3,r2 8011dc: 10800c04 addi r2,r2,48 8011e0: 10c00007 ldb r3,0(r2) 8011e4: e0800607 ldb r2,24(fp) 8011e8: 18802126 beq r3,r2,801270 <lcd_repaint_screen+0x17c> { unsigned char address = x + colstart[y]; 8011ec: e0c00117 ldw r3,4(fp) 8011f0: d0a00504 addi r2,gp,-32748 8011f4: 1885883a add r2,r3,r2 8011f8: e0c00217 ldw r3,8(fp) 8011fc: 11000003 ldbu r4,0(r2) 801200: 1805883a mov r2,r3 801204: 2085883a add r2,r4,r2 801208: e0800645 stb r2,25(fp) if (address != sp->address) 80120c: e0c00643 ldbu r3,25(fp) 801210: e0800017 ldw r2,0(fp) 801214: 108008c7 ldb r2,35(r2) 801218: 18800926 beq r3,r2,801240 <lcd_repaint_screen+0x14c> { lcd_write_command(sp, LCD_CMD_WRITE_DATA | address); 80121c: e0c00643 ldbu r3,25(fp) 801220: 00bfe004 movi r2,-128 801224: 1884b03a or r2,r3,r2 801228: 11403fcc andi r5,r2,255 80122c: e1000017 ldw r4,0(fp) 801230: 0800ec80 call 800ec8 <lcd_write_command> sp->address = address; 801234: e0c00017 ldw r3,0(fp) 801238: e0800643 ldbu r2,25(fp) 80123c: 188008c5 stb r2,35(r3) } lcd_write_data(sp, c); 801240: e1400603 ldbu r5,24(fp) 801244: e1000017 ldw r4,0(fp) 801248: 0800f700 call 800f70 <lcd_write_data> sp->line[y].visible[x] = c; 80124c: e0c00017 ldw r3,0(fp) 801250: e0800117 ldw r2,4(fp) 801254: 108018e4 muli r2,r2,99 801258: 10c7883a add r3,r2,r3 80125c: e0800217 ldw r2,8(fp) 801260: 1885883a add r2,r3,r2 801264: 10c00c04 addi r3,r2,48 801268: e0800603 ldbu r2,24(fp) 80126c: 18800005 stb r2,0(r3) 801270: e0800217 ldw r2,8(fp) 801274: 10800044 addi r2,r2,1 801278: e0800215 stw r2,8(fp) 80127c: 003fc006 br 801180 <lcd_repaint_screen+0x8c> 801280: e0800117 ldw r2,4(fp) 801284: 10800044 addi r2,r2,1 801288: e0800115 stw r2,4(fp) 80128c: 003fa306 br 80111c <lcd_repaint_screen+0x28> } } } } 801290: dfc00917 ldw ra,36(sp) 801294: df000817 ldw fp,32(sp) 801298: dc000717 ldw r16,28(sp) 80129c: dec00a04 addi sp,sp,40 8012a0: f800283a ret 008012a4 <lcd_scroll_up>: /* --------------------------------------------------------------------- */ static void lcd_scroll_up(altera_avalon_lcd_16207_state* sp) { 8012a4: defffc04 addi sp,sp,-16 8012a8: dfc00315 stw ra,12(sp) 8012ac: df000215 stw fp,8(sp) 8012b0: d839883a mov fp,sp 8012b4: e1000015 stw r4,0(fp) int y; for (y = 0 ; y < ALT_LCD_HEIGHT ; y++) 8012b8: e0000115 stw zero,4(fp) 8012bc: e0800117 ldw r2,4(fp) 8012c0: 10800088 cmpgei r2,r2,2 8012c4: 10001c1e bne r2,zero,801338 <lcd_scroll_up+0x94> { if (y < ALT_LCD_HEIGHT-1) 8012c8: e0800117 ldw r2,4(fp) 8012cc: 10800048 cmpgei r2,r2,1 8012d0: 10000d1e bne r2,zero,801308 <lcd_scroll_up+0x64> memcpy(sp->line[y].data, sp->line[y+1].data, ALT_LCD_VIRTUAL_WIDTH); 8012d4: e0800117 ldw r2,4(fp) 8012d8: 10c018e4 muli r3,r2,99 8012dc: e0800017 ldw r2,0(fp) 8012e0: 1885883a add r2,r3,r2 8012e4: 11001004 addi r4,r2,64 8012e8: e0800117 ldw r2,4(fp) 8012ec: 10c018e4 muli r3,r2,99 8012f0: e0800017 ldw r2,0(fp) 8012f4: 1885883a add r2,r3,r2 8012f8: 114028c4 addi r5,r2,163 8012fc: 01801404 movi r6,80 801300: 08034840 call 803484 <memcpy> 801304: 00000806 br 801328 <lcd_scroll_up+0x84> else memset(sp->line[y].data, ' ', ALT_LCD_VIRTUAL_WIDTH); 801308: e0800117 ldw r2,4(fp) 80130c: 10c018e4 muli r3,r2,99 801310: e0800017 ldw r2,0(fp) 801314: 1885883a add r2,r3,r2 801318: 11001004 addi r4,r2,64 80131c: 01400804 movi r5,32 801320: 01801404 movi r6,80 801324: 08035400 call 803540 <memset> 801328: e0800117 ldw r2,4(fp) 80132c: 10800044 addi r2,r2,1 801330: e0800115 stw r2,4(fp) 801334: 003fe106 br 8012bc <lcd_scroll_up+0x18> } sp->y--; 801338: e0c00017 ldw r3,0(fp) 80133c: e0800017 ldw r2,0(fp) 801340: 10800883 ldbu r2,34(r2) 801344: 10bfffc4 addi r2,r2,-1 801348: 18800885 stb r2,34(r3) } 80134c: dfc00317 ldw ra,12(sp) 801350: df000217 ldw fp,8(sp) 801354: dec00404 addi sp,sp,16 801358: f800283a ret 0080135c <lcd_handle_escape>: /* --------------------------------------------------------------------- */ static void lcd_handle_escape(altera_avalon_lcd_16207_state* sp, char c) { 80135c: defff804 addi sp,sp,-32 801360: dfc00715 stw ra,28(sp) 801364: df000615 stw fp,24(sp) 801368: d839883a mov fp,sp 80136c: e1000015 stw r4,0(fp) 801370: e1400105 stb r5,4(fp) int parm1 = 0, parm2 = 0; 801374: e0000215 stw zero,8(fp) 801378: e0000315 stw zero,12(fp) if (sp->escape[0] == '[') 80137c: e0800017 ldw r2,0(fp) 801380: 10800a07 ldb r2,40(r2) 801384: 108016d8 cmpnei r2,r2,91 801388: 1000361e bne r2,zero,801464 <lcd_handle_escape+0x108> { char * ptr = sp->escape+1; 80138c: e0800017 ldw r2,0(fp) 801390: 10800a44 addi r2,r2,41 801394: e0800415 stw r2,16(fp) while (isdigit(*ptr)) 801398: e0800417 ldw r2,16(fp) 80139c: 10c00007 ldb r3,0(r2) 8013a0: 00802034 movhi r2,128 8013a4: 108f5c04 addi r2,r2,15728 8013a8: 1885883a add r2,r3,r2 8013ac: 10800003 ldbu r2,0(r2) 8013b0: 1004d0ba srli r2,r2,2 8013b4: 1080004c andi r2,r2,1 8013b8: 1005003a cmpeq r2,r2,zero 8013bc: 10000c1e bne r2,zero,8013f0 <lcd_handle_escape+0x94> parm1 = (parm1 * 10) + (*ptr++ - '0'); 8013c0: e0800217 ldw r2,8(fp) 8013c4: 110002a4 muli r4,r2,10 8013c8: e1400404 addi r5,fp,16 8013cc: 28c00017 ldw r3,0(r5) 8013d0: 1805883a mov r2,r3 8013d4: 10800007 ldb r2,0(r2) 8013d8: 2085883a add r2,r4,r2 8013dc: 10bff404 addi r2,r2,-48 8013e0: 18c00044 addi r3,r3,1 8013e4: 28c00015 stw r3,0(r5) 8013e8: e0800215 stw r2,8(fp) 8013ec: 003fea06 br 801398 <lcd_handle_escape+0x3c> if (*ptr == ';') 8013f0: e0800417 ldw r2,16(fp) 8013f4: 10800007 ldb r2,0(r2) 8013f8: 10800ed8 cmpnei r2,r2,59 8013fc: 10001b1e bne r2,zero,80146c <lcd_handle_escape+0x110> { ptr++; 801400: e0800417 ldw r2,16(fp) 801404: 10800044 addi r2,r2,1 801408: e0800415 stw r2,16(fp) while (isdigit(*ptr)) 80140c: e0800417 ldw r2,16(fp) 801410: 10c00007 ldb r3,0(r2) 801414: 00802034 movhi r2,128 801418: 108f5c04 addi r2,r2,15728 80141c: 1885883a add r2,r3,r2 801420: 10800003 ldbu r2,0(r2) 801424: 1004d0ba srli r2,r2,2 801428: 1080004c andi r2,r2,1 80142c: 1005003a cmpeq r2,r2,zero 801430: 10000e1e bne r2,zero,80146c <lcd_handle_escape+0x110> parm2 = (parm2 * 10) + (*ptr++ - '0'); 801434: e0800317 ldw r2,12(fp) 801438: 110002a4 muli r4,r2,10 80143c: e1400404 addi r5,fp,16 801440: 28c00017 ldw r3,0(r5) 801444: 1805883a mov r2,r3 801448: 10800007 ldb r2,0(r2) 80144c: 2085883a add r2,r4,r2 801450: 10bff404 addi r2,r2,-48 801454: 18c00044 addi r3,r3,1 801458: 28c00015 stw r3,0(r5) 80145c: e0800315 stw r2,12(fp) 801460: 003fea06 br 80140c <lcd_handle_escape+0xb0> } } else parm1 = -1; 801464: 00bfffc4 movi r2,-1 801468: e0800215 stw r2,8(fp) switch (c) 80146c: e0800107 ldb r2,4(fp) 801470: e0800515 stw r2,20(fp) 801474: e0c00517 ldw r3,20(fp) 801478: 188012a0 cmpeqi r2,r3,74 80147c: 10002a1e bne r2,zero,801528 <lcd_handle_escape+0x1cc> 801480: e0c00517 ldw r3,20(fp) 801484: 188012c8 cmpgei r2,r3,75 801488: 1000041e bne r2,zero,80149c <lcd_handle_escape+0x140> 80148c: e0c00517 ldw r3,20(fp) 801490: 18801220 cmpeqi r2,r3,72 801494: 1000081e bne r2,zero,8014b8 <lcd_handle_escape+0x15c> 801498: 00003f06 br 801598 <lcd_handle_escape+0x23c> 80149c: e0c00517 ldw r3,20(fp) 8014a0: 188012e0 cmpeqi r2,r3,75 8014a4: 1000261e bne r2,zero,801540 <lcd_handle_escape+0x1e4> 8014a8: e0c00517 ldw r3,20(fp) 8014ac: 188019a0 cmpeqi r2,r3,102 8014b0: 1000011e bne r2,zero,8014b8 <lcd_handle_escape+0x15c> 8014b4: 00003806 br 801598 <lcd_handle_escape+0x23c> { case 'H': /* ESC '[' <y> ';' <x> 'H' : Move cursor to location */ case 'f': /* Same as above */ if (parm2 > 0) 8014b8: e0800317 ldw r2,12(fp) 8014bc: 10800050 cmplti r2,r2,1 8014c0: 1000041e bne r2,zero,8014d4 <lcd_handle_escape+0x178> sp->x = parm2 - 1; 8014c4: e0c00017 ldw r3,0(fp) 8014c8: e0800317 ldw r2,12(fp) 8014cc: 10bfffc4 addi r2,r2,-1 8014d0: 18800845 stb r2,33(r3) if (parm1 > 0) 8014d4: e0800217 ldw r2,8(fp) 8014d8: 10800050 cmplti r2,r2,1 8014dc: 10002e1e bne r2,zero,801598 <lcd_handle_escape+0x23c> { sp->y = parm1 - 1; 8014e0: e0c00017 ldw r3,0(fp) 8014e4: e0800217 ldw r2,8(fp) 8014e8: 10bfffc4 addi r2,r2,-1 8014ec: 18800885 stb r2,34(r3) if (sp->y > ALT_LCD_HEIGHT * 2) 8014f0: e0800017 ldw r2,0(fp) 8014f4: 10800883 ldbu r2,34(r2) 8014f8: 10800170 cmpltui r2,r2,5 8014fc: 1000031e bne r2,zero,80150c <lcd_handle_escape+0x1b0> sp->y = ALT_LCD_HEIGHT * 2; 801500: e0c00017 ldw r3,0(fp) 801504: 00800104 movi r2,4 801508: 18800885 stb r2,34(r3) while (sp->y > ALT_LCD_HEIGHT) 80150c: e0800017 ldw r2,0(fp) 801510: 10800883 ldbu r2,34(r2) 801514: 108000f0 cmpltui r2,r2,3 801518: 10001f1e bne r2,zero,801598 <lcd_handle_escape+0x23c> lcd_scroll_up(sp); 80151c: e1000017 ldw r4,0(fp) 801520: 08012a40 call 8012a4 <lcd_scroll_up> 801524: 003ff906 br 80150c <lcd_handle_escape+0x1b0> } break; case 'J': /* ESC J is clear to beginning of line [unimplemented] * ESC [ 0 J is clear to bottom of screen [unimplemented] * ESC [ 1 J is clear to beginning of screen [unimplemented] * ESC [ 2 J is clear screen */ if (parm1 == 2) 801528: e0800217 ldw r2,8(fp) 80152c: 10800098 cmpnei r2,r2,2 801530: 1000191e bne r2,zero,801598 <lcd_handle_escape+0x23c> lcd_clear_screen(sp); 801534: e1000017 ldw r4,0(fp) 801538: 08010340 call 801034 <lcd_clear_screen> break; 80153c: 00001606 br 801598 <lcd_handle_escape+0x23c> case 'K': /* ESC K is clear to end of line * ESC [ 0 K is clear to end of line * ESC [ 1 K is clear to beginning of line [unimplemented] * ESC [ 2 K is clear line [unimplemented] */ if (parm1 < 1) 801540: e0800217 ldw r2,8(fp) 801544: 10800048 cmpgei r2,r2,1 801548: 1000131e bne r2,zero,801598 <lcd_handle_escape+0x23c> { if (sp->x < ALT_LCD_VIRTUAL_WIDTH) 80154c: e0800017 ldw r2,0(fp) 801550: 10800843 ldbu r2,33(r2) 801554: 10801428 cmpgeui r2,r2,80 801558: 10000f1e bne r2,zero,801598 <lcd_handle_escape+0x23c> memset(sp->line[sp->y].data + sp->x, ' ', ALT_LCD_VIRTUAL_WIDTH - sp->x); 80155c: e0800017 ldw r2,0(fp) 801560: 10800883 ldbu r2,34(r2) 801564: 10c018e4 muli r3,r2,99 801568: e0800017 ldw r2,0(fp) 80156c: 1887883a add r3,r3,r2 801570: e0800017 ldw r2,0(fp) 801574: 10800843 ldbu r2,33(r2) 801578: 1885883a add r2,r3,r2 80157c: 11001004 addi r4,r2,64 801580: e0800017 ldw r2,0(fp) 801584: 10c00843 ldbu r3,33(r2) 801588: 00801404 movi r2,80 80158c: 10cdc83a sub r6,r2,r3 801590: 01400804 movi r5,32 801594: 08035400 call 803540 <memset> } break; } } 801598: dfc00717 ldw ra,28(sp) 80159c: df000617 ldw fp,24(sp) 8015a0: dec00804 addi sp,sp,32 8015a4: f800283a ret 008015a8 <altera_avalon_lcd_16207_write>: /* --------------------------------------------------------------------- */ int altera_avalon_lcd_16207_write(altera_avalon_lcd_16207_state* sp, const char* ptr, int len, int flags) { 8015a8: defff304 addi sp,sp,-52 8015ac: dfc00c15 stw ra,48(sp) 8015b0: df000b15 stw fp,44(sp) 8015b4: dc000a15 stw r16,40(sp) 8015b8: d839883a mov fp,sp 8015bc: e1000015 stw r4,0(fp) 8015c0: e1400115 stw r5,4(fp) 8015c4: e1800215 stw r6,8(fp) 8015c8: e1c00315 stw r7,12(fp) const char* end = ptr + len; 8015cc: e0c00117 ldw r3,4(fp) 8015d0: e0800217 ldw r2,8(fp) 8015d4: 1885883a add r2,r3,r2 8015d8: e0800415 stw r2,16(fp) */ static ALT_INLINE int ALT_ALWAYS_INLINE alt_no_error (void) { return 0; 8015dc: e0000715 stw zero,28(fp) int y; int widthmax; /* When running in a multi threaded environment, obtain the "write_lock" * semaphore. This ensures that writing to the device is thread-safe. */ ALT_SEM_PEND (sp->write_lock, 0); /* Tell the routine which is called off the timer interrupt that the * foreground routines are active so it must not repaint the display. */ sp->active = 1; 8015e0: e0c00017 ldw r3,0(fp) 8015e4: 00800044 movi r2,1 8015e8: 188009c5 stb r2,39(r3) for ( ; ptr < end ; ptr++) 8015ec: e0c00117 ldw r3,4(fp) 8015f0: e0800417 ldw r2,16(fp) 8015f4: 18808c2e bgeu r3,r2,801828 <altera_avalon_lcd_16207_write+0x280> { char c = *ptr; 8015f8: e0800117 ldw r2,4(fp) 8015fc: 10800003 ldbu r2,0(r2) 801600: e0800805 stb r2,32(fp) if (sp->esccount >= 0) 801604: e0800017 ldw r2,0(fp) 801608: 10800907 ldb r2,36(r2) 80160c: 1004803a cmplt r2,r2,zero 801610: 1000351e bne r2,zero,8016e8 <altera_avalon_lcd_16207_write+0x140> { unsigned int esccount = sp->esccount; 801614: e0800017 ldw r2,0(fp) 801618: 10800907 ldb r2,36(r2) 80161c: e0800915 stw r2,36(fp) /* Single character escape sequences can end with any character * Multi character escape sequences start with '[' and contain * digits and semicolons before terminating */ if ((esccount == 0 && c != '[') || 801620: e0800917 ldw r2,36(fp) 801624: 1004c03a cmpne r2,r2,zero 801628: 1000031e bne r2,zero,801638 <altera_avalon_lcd_16207_write+0x90> 80162c: e0800807 ldb r2,32(fp) 801630: 108016d8 cmpnei r2,r2,91 801634: 1000101e bne r2,zero,801678 <altera_avalon_lcd_16207_write+0xd0> 801638: e0800917 ldw r2,36(fp) 80163c: 1005003a cmpeq r2,r2,zero 801640: 1000191e bne r2,zero,8016a8 <altera_avalon_lcd_16207_write+0x100> 801644: e0c00807 ldb r3,32(fp) 801648: 00802034 movhi r2,128 80164c: 108f5c04 addi r2,r2,15728 801650: 1885883a add r2,r3,r2 801654: 10800003 ldbu r2,0(r2) 801658: 1004d0ba srli r2,r2,2 80165c: 1080004c andi r2,r2,1 801660: 1004c03a cmpne r2,r2,zero 801664: 1000101e bne r2,zero,8016a8 <altera_avalon_lcd_16207_write+0x100> 801668: e0800807 ldb r2,32(fp) 80166c: 10800ed8 cmpnei r2,r2,59 801670: 1000011e bne r2,zero,801678 <altera_avalon_lcd_16207_write+0xd0> 801674: 00000c06 br 8016a8 <altera_avalon_lcd_16207_write+0x100> (esccount > 0 && !isdigit(c) && c != ';')) { sp->escape[esccount] = 0; 801678: e0c00017 ldw r3,0(fp) 80167c: e0800917 ldw r2,36(fp) 801680: 1885883a add r2,r3,r2 801684: 10800a04 addi r2,r2,40 801688: 10000005 stb zero,0(r2) lcd_handle_escape(sp, c); 80168c: e1400807 ldb r5,32(fp) 801690: e1000017 ldw r4,0(fp) 801694: 080135c0 call 80135c <lcd_handle_escape> sp->esccount = -1; 801698: e0c00017 ldw r3,0(fp) 80169c: 00bfffc4 movi r2,-1 8016a0: 18800905 stb r2,36(r3) 8016a4: 00005c06 br 801818 <altera_avalon_lcd_16207_write+0x270> } else if (sp->esccount < sizeof(sp->escape)-1) 8016a8: e0800017 ldw r2,0(fp) 8016ac: 10800903 ldbu r2,36(r2) 8016b0: 108001e8 cmpgeui r2,r2,7 8016b4: 1000581e bne r2,zero,801818 <altera_avalon_lcd_16207_write+0x270> { sp->escape[esccount] = c; 8016b8: e0c00017 ldw r3,0(fp) 8016bc: e0800917 ldw r2,36(fp) 8016c0: 1885883a add r2,r3,r2 8016c4: 10c00a04 addi r3,r2,40 8016c8: e0800803 ldbu r2,32(fp) 8016cc: 18800005 stb r2,0(r3) sp->esccount++; 8016d0: e0c00017 ldw r3,0(fp) 8016d4: e0800017 ldw r2,0(fp) 8016d8: 10800903 ldbu r2,36(r2) 8016dc: 10800044 addi r2,r2,1 8016e0: 18800905 stb r2,36(r3) 8016e4: 00004c06 br 801818 <altera_avalon_lcd_16207_write+0x270> } } else if (c == 27) /* ESC */ 8016e8: e0800807 ldb r2,32(fp) 8016ec: 108006d8 cmpnei r2,r2,27 8016f0: 1000031e bne r2,zero,801700 <altera_avalon_lcd_16207_write+0x158> { sp->esccount = 0; 8016f4: e0800017 ldw r2,0(fp) 8016f8: 10000905 stb zero,36(r2) 8016fc: 00004606 br 801818 <altera_avalon_lcd_16207_write+0x270> } else if (c == '\r') 801700: e0800807 ldb r2,32(fp) 801704: 10800358 cmpnei r2,r2,13 801708: 1000031e bne r2,zero,801718 <altera_avalon_lcd_16207_write+0x170> { sp->x = 0; 80170c: e0800017 ldw r2,0(fp) 801710: 10000845 stb zero,33(r2) 801714: 00004006 br 801818 <altera_avalon_lcd_16207_write+0x270> } else if (c == '\n') 801718: e0800807 ldb r2,32(fp) 80171c: 10800298 cmpnei r2,r2,10 801720: 10000e1e bne r2,zero,80175c <altera_avalon_lcd_16207_write+0x1b4> { sp->x = 0; 801724: e0800017 ldw r2,0(fp) 801728: 10000845 stb zero,33(r2) sp->y++; 80172c: e0c00017 ldw r3,0(fp) 801730: e0800017 ldw r2,0(fp) 801734: 10800883 ldbu r2,34(r2) 801738: 10800044 addi r2,r2,1 80173c: 18800885 stb r2,34(r3) /* Let the cursor sit at X=0, Y=HEIGHT without scrolling so the user * can print two lines of data without losing one. */ if (sp->y > ALT_LCD_HEIGHT) 801740: e0800017 ldw r2,0(fp) 801744: 10800883 ldbu r2,34(r2) 801748: 108000f0 cmpltui r2,r2,3 80174c: 1000321e bne r2,zero,801818 <altera_avalon_lcd_16207_write+0x270> lcd_scroll_up(sp); 801750: e1000017 ldw r4,0(fp) 801754: 08012a40 call 8012a4 <lcd_scroll_up> 801758: 00002f06 br 801818 <altera_avalon_lcd_16207_write+0x270> } else if (c == '\b') 80175c: e0800807 ldb r2,32(fp) 801760: 10800218 cmpnei r2,r2,8 801764: 10000a1e bne r2,zero,801790 <altera_avalon_lcd_16207_write+0x1e8> { if (sp->x > 0) 801768: e0800017 ldw r2,0(fp) 80176c: 10800843 ldbu r2,33(r2) 801770: 1005003a cmpeq r2,r2,zero 801774: 1000281e bne r2,zero,801818 <altera_avalon_lcd_16207_write+0x270> sp->x--; 801778: e0c00017 ldw r3,0(fp) 80177c: e0800017 ldw r2,0(fp) 801780: 10800843 ldbu r2,33(r2) 801784: 10bfffc4 addi r2,r2,-1 801788: 18800845 stb r2,33(r3) 80178c: 00002206 br 801818 <altera_avalon_lcd_16207_write+0x270> } else if (isprint(c)) 801790: e0c00807 ldb r3,32(fp) 801794: 00802034 movhi r2,128 801798: 108f5c04 addi r2,r2,15728 80179c: 1885883a add r2,r3,r2 8017a0: 10800007 ldb r2,0(r2) 8017a4: 108025cc andi r2,r2,151 8017a8: 1005003a cmpeq r2,r2,zero 8017ac: 10001a1e bne r2,zero,801818 <altera_avalon_lcd_16207_write+0x270> { /* If we didn't scroll on the last linefeed then we might need to do * it now. */ if (sp->y >= ALT_LCD_HEIGHT) 8017b0: e0800017 ldw r2,0(fp) 8017b4: 10800883 ldbu r2,34(r2) 8017b8: 108000b0 cmpltui r2,r2,2 8017bc: 1000021e bne r2,zero,8017c8 <altera_avalon_lcd_16207_write+0x220> lcd_scroll_up(sp); 8017c0: e1000017 ldw r4,0(fp) 8017c4: 08012a40 call 8012a4 <lcd_scroll_up> if (sp->x < ALT_LCD_VIRTUAL_WIDTH) 8017c8: e0800017 ldw r2,0(fp) 8017cc: 10800843 ldbu r2,33(r2) 8017d0: 10801428 cmpgeui r2,r2,80 8017d4: 10000b1e bne r2,zero,801804 <altera_avalon_lcd_16207_write+0x25c> sp->line[sp->y].data[sp->x] = c; 8017d8: e1000017 ldw r4,0(fp) 8017dc: e0800017 ldw r2,0(fp) 8017e0: 10c00843 ldbu r3,33(r2) 8017e4: e0800017 ldw r2,0(fp) 8017e8: 10800883 ldbu r2,34(r2) 8017ec: 108018e4 muli r2,r2,99 8017f0: 1105883a add r2,r2,r4 8017f4: 10c5883a add r2,r2,r3 8017f8: 10c01004 addi r3,r2,64 8017fc: e0800803 ldbu r2,32(fp) 801800: 18800005 stb r2,0(r3) sp->x++; 801804: e0c00017 ldw r3,0(fp) 801808: e0800017 ldw r2,0(fp) 80180c: 10800843 ldbu r2,33(r2) 801810: 10800044 addi r2,r2,1 801814: 18800845 stb r2,33(r3) 801818: e0800117 ldw r2,4(fp) 80181c: 10800044 addi r2,r2,1 801820: e0800115 stw r2,4(fp) 801824: 003f7106 br 8015ec <altera_avalon_lcd_16207_write+0x44> } } /* Recalculate the scrolling parameters */ widthmax = ALT_LCD_WIDTH; 801828: 00800404 movi r2,16 80182c: e0800615 stw r2,24(fp) for (y = 0 ; y < ALT_LCD_HEIGHT ; y++) 801830: e0000515 stw zero,20(fp) 801834: e0800517 ldw r2,20(fp) 801838: 10800088 cmpgei r2,r2,2 80183c: 1000331e bne r2,zero,80190c <altera_avalon_lcd_16207_write+0x364> { int width; for (width = ALT_LCD_VIRTUAL_WIDTH ; width > 0 ; width--) 801840: 00801404 movi r2,80 801844: e0800915 stw r2,36(fp) 801848: e0800917 ldw r2,36(fp) 80184c: 10800050 cmplti r2,r2,1 801850: 10000f1e bne r2,zero,801890 <altera_avalon_lcd_16207_write+0x2e8> if (sp->line[y].data[width-1] != ' ') 801854: e0c00017 ldw r3,0(fp) 801858: e0800517 ldw r2,20(fp) 80185c: 108018e4 muli r2,r2,99 801860: 10c7883a add r3,r2,r3 801864: e0800917 ldw r2,36(fp) 801868: 1885883a add r2,r3,r2 80186c: 10800fc4 addi r2,r2,63 801870: 10800007 ldb r2,0(r2) 801874: 10800820 cmpeqi r2,r2,32 801878: 1000011e bne r2,zero,801880 <altera_avalon_lcd_16207_write+0x2d8> break; 80187c: 00000406 br 801890 <altera_avalon_lcd_16207_write+0x2e8> 801880: e0800917 ldw r2,36(fp) 801884: 10bfffc4 addi r2,r2,-1 801888: e0800915 stw r2,36(fp) 80188c: 003fee06 br 801848 <altera_avalon_lcd_16207_write+0x2a0> /* The minimum width is the size of the LCD panel. If the real width * is long enough to require scrolling then add an extra space so the * end of the message doesn't run into the beginning of it. */ if (width <= ALT_LCD_WIDTH) 801890: e0800917 ldw r2,36(fp) 801894: 10800448 cmpgei r2,r2,17 801898: 1000031e bne r2,zero,8018a8 <altera_avalon_lcd_16207_write+0x300> width = ALT_LCD_WIDTH; 80189c: 00800404 movi r2,16 8018a0: e0800915 stw r2,36(fp) 8018a4: 00000306 br 8018b4 <altera_avalon_lcd_16207_write+0x30c> else width++; 8018a8: e0800917 ldw r2,36(fp) 8018ac: 10800044 addi r2,r2,1 8018b0: e0800915 stw r2,36(fp) sp->line[y].width = width; 8018b4: e0c00017 ldw r3,0(fp) 8018b8: e0800517 ldw r2,20(fp) 8018bc: 108018e4 muli r2,r2,99 8018c0: 10c5883a add r2,r2,r3 8018c4: 10c02404 addi r3,r2,144 8018c8: e0800917 ldw r2,36(fp) 8018cc: 18800045 stb r2,1(r3) if (widthmax < width) 8018d0: e0c00617 ldw r3,24(fp) 8018d4: e0800917 ldw r2,36(fp) 8018d8: 1880020e bge r3,r2,8018e4 <altera_avalon_lcd_16207_write+0x33c> widthmax = width; 8018dc: e0800917 ldw r2,36(fp) 8018e0: e0800615 stw r2,24(fp) sp->line[y].speed = 0; /* By default lines don't scroll */ 8018e4: e0c00017 ldw r3,0(fp) 8018e8: e0800517 ldw r2,20(fp) 8018ec: 108018e4 muli r2,r2,99 8018f0: 10c5883a add r2,r2,r3 8018f4: 10802404 addi r2,r2,144 8018f8: 10000085 stb zero,2(r2) 8018fc: e0800517 ldw r2,20(fp) 801900: 10800044 addi r2,r2,1 801904: e0800515 stw r2,20(fp) 801908: 003fca06 br 801834 <altera_avalon_lcd_16207_write+0x28c> } if (widthmax <= ALT_LCD_WIDTH) 80190c: e0800617 ldw r2,24(fp) 801910: 10800448 cmpgei r2,r2,17 801914: 1000031e bne r2,zero,801924 <altera_avalon_lcd_16207_write+0x37c> sp->scrollmax = 0; 801918: e0800017 ldw r2,0(fp) 80191c: 10000985 stb zero,38(r2) 801920: 00002606 br 8019bc <altera_avalon_lcd_16207_write+0x414> else { widthmax *= 2; 801924: e0c00617 ldw r3,24(fp) 801928: 1805883a mov r2,r3 80192c: 10c5883a add r2,r2,r3 801930: e0800615 stw r2,24(fp) sp->scrollmax = widthmax; 801934: e0c00017 ldw r3,0(fp) 801938: e0800617 ldw r2,24(fp) 80193c: 18800985 stb r2,38(r3) /* Now calculate how fast each of the other lines should go */ for (y = 0 ; y < ALT_LCD_HEIGHT ; y++) 801940: e0000515 stw zero,20(fp) 801944: e0800517 ldw r2,20(fp) 801948: 10800088 cmpgei r2,r2,2 80194c: 10001b1e bne r2,zero,8019bc <altera_avalon_lcd_16207_write+0x414> if (sp->line[y].width > ALT_LCD_WIDTH) 801950: e0c00017 ldw r3,0(fp) 801954: e0800517 ldw r2,20(fp) 801958: 108018e4 muli r2,r2,99 80195c: 10c5883a add r2,r2,r3 801960: 10802404 addi r2,r2,144 801964: 10800047 ldb r2,1(r2) 801968: 10800450 cmplti r2,r2,17 80196c: 10000f1e bne r2,zero,8019ac <altera_avalon_lcd_16207_write+0x404> { /* You have three options for how to make the display scroll, chosen * using the preprocessor directives below */ #if 1 /* This option makes all the lines scroll round at different speeds * which are chosen so that all the scrolls finish at the same time. */ sp->line[y].speed = 256 * sp->line[y].width / widthmax; 801970: e0c00017 ldw r3,0(fp) 801974: e0800517 ldw r2,20(fp) 801978: 108018e4 muli r2,r2,99 80197c: 10c5883a add r2,r2,r3 801980: 14002404 addi r16,r2,144 801984: e0c00017 ldw r3,0(fp) 801988: e0800517 ldw r2,20(fp) 80198c: 108018e4 muli r2,r2,99 801990: 10c5883a add r2,r2,r3 801994: 10802404 addi r2,r2,144 801998: 10800047 ldb r2,1(r2) 80199c: 11004024 muli r4,r2,256 8019a0: e1400617 ldw r5,24(fp) 8019a4: 0803ac00 call 803ac0 <__divsi3> 8019a8: 80800085 stb r2,2(r16) 8019ac: e0800517 ldw r2,20(fp) 8019b0: 10800044 addi r2,r2,1 8019b4: e0800515 stw r2,20(fp) 8019b8: 003fe206 br 801944 <altera_avalon_lcd_16207_write+0x39c> #elif 1 /* This option pads the shorter lines with spaces so that they all * scroll together. */ sp->line[y].width = widthmax / 2; sp->line[y].speed = 256/2; #else /* This option makes the shorter lines stop after they have rotated * and waits for the longer lines to catch up */ sp->line[y].speed = 256/2; #endif } } /* Repaint once, then check whether there has been a missed repaint * (because active was set when the timer interrupt occurred). If there * has been a missed repaint then paint again. And again. etc. */ for ( ; ; ) { int old_scrollpos = sp->scrollpos; 8019bc: e0800017 ldw r2,0(fp) 8019c0: 10800947 ldb r2,37(r2) 8019c4: e0800915 stw r2,36(fp) lcd_repaint_screen(sp); 8019c8: e1000017 ldw r4,0(fp) 8019cc: 08010f40 call 8010f4 <lcd_repaint_screen> /* Let the timer routines repaint the display again */ sp->active = 0; 8019d0: e0800017 ldw r2,0(fp) 8019d4: 100009c5 stb zero,39(r2) /* Have the timer routines tried to scroll while we were painting? * If not then we can exit */ if (sp->scrollpos == old_scrollpos) 8019d8: e0800017 ldw r2,0(fp) 8019dc: 10c00947 ldb r3,37(r2) 8019e0: e0800917 ldw r2,36(fp) 8019e4: 1880011e bne r3,r2,8019ec <altera_avalon_lcd_16207_write+0x444> break; 8019e8: 00000406 br 8019fc <altera_avalon_lcd_16207_write+0x454> /* We need to repaint again since the display scrolled while we were * painting last time */ sp->active = 1; 8019ec: e0c00017 ldw r3,0(fp) 8019f0: 00800044 movi r2,1 8019f4: 188009c5 stb r2,39(r3) 8019f8: 003ff006 br 8019bc <altera_avalon_lcd_16207_write+0x414> */ static ALT_INLINE int ALT_ALWAYS_INLINE alt_no_error (void) { return 0; 8019fc: e0000915 stw zero,36(fp) } /* Now that access to the display is complete, release the write * semaphore so that other threads can access the buffer. */ ALT_SEM_POST (sp->write_lock); return len; 801a00: e0800217 ldw r2,8(fp) } 801a04: dfc00c17 ldw ra,48(sp) 801a08: df000b17 ldw fp,44(sp) 801a0c: dc000a17 ldw r16,40(sp) 801a10: dec00d04 addi sp,sp,52 801a14: f800283a ret 00801a18 <alt_lcd_16207_timeout>: /* --------------------------------------------------------------------- */ /* This should be in a top level header file really */ #define container_of(ptr, type, member) ((type *)((char *)ptr - offsetof(type, member))) /* * Timeout routine is called every second */ static alt_u32 alt_lcd_16207_timeout(void* context) { 801a18: defffc04 addi sp,sp,-16 801a1c: dfc00315 stw ra,12(sp) 801a20: df000215 stw fp,8(sp) 801a24: d839883a mov fp,sp 801a28: e1000015 stw r4,0(fp) altera_avalon_lcd_16207_state* sp = (altera_avalon_lcd_16207_state*)context; 801a2c: e0800017 ldw r2,0(fp) 801a30: e0800115 stw r2,4(fp) /* Update the scrolling position */ if (sp->scrollpos + 1 >= sp->scrollmax) 801a34: e0800117 ldw r2,4(fp) 801a38: 10800947 ldb r2,37(r2) 801a3c: 10c00044 addi r3,r2,1 801a40: e0800117 ldw r2,4(fp) 801a44: 10800987 ldb r2,38(r2) 801a48: 18800316 blt r3,r2,801a58 <alt_lcd_16207_timeout+0x40> sp->scrollpos = 0; 801a4c: e0800117 ldw r2,4(fp) 801a50: 10000945 stb zero,37(r2) 801a54: 00000506 br 801a6c <alt_lcd_16207_timeout+0x54> else sp->scrollpos = sp->scrollpos + 1; 801a58: e0c00117 ldw r3,4(fp) 801a5c: e0800117 ldw r2,4(fp) 801a60: 10800943 ldbu r2,37(r2) 801a64: 10800044 addi r2,r2,1 801a68: 18800945 stb r2,37(r3) /* Repaint the panel unless the foreground will do it again soon */ if (sp->scrollmax > 0 && !sp->active) 801a6c: e0800117 ldw r2,4(fp) 801a70: 10800987 ldb r2,38(r2) 801a74: 10800050 cmplti r2,r2,1 801a78: 1000061e bne r2,zero,801a94 <alt_lcd_16207_timeout+0x7c> 801a7c: e0800117 ldw r2,4(fp) 801a80: 108009c7 ldb r2,39(r2) 801a84: 1004c03a cmpne r2,r2,zero 801a88: 1000021e bne r2,zero,801a94 <alt_lcd_16207_timeout+0x7c> lcd_repaint_screen(sp); 801a8c: e1000117 ldw r4,4(fp) 801a90: 08010f40 call 8010f4 <lcd_repaint_screen> return sp->period; 801a94: e0800117 ldw r2,4(fp) 801a98: 10800717 ldw r2,28(r2) } 801a9c: dfc00317 ldw ra,12(sp) 801aa0: df000217 ldw fp,8(sp) 801aa4: dec00404 addi sp,sp,16 801aa8: f800283a ret 00801aac <altera_avalon_lcd_16207_init>: /* --------------------------------------------------------------------- */ /* * Called at boot time to initialise the LCD driver */ void altera_avalon_lcd_16207_init(altera_avalon_lcd_16207_state* sp) { 801aac: defff904 addi sp,sp,-28 801ab0: dfc00615 stw ra,24(sp) 801ab4: df000515 stw fp,20(sp) 801ab8: dc000415 stw r16,16(sp) 801abc: d839883a mov fp,sp 801ac0: e1000015 stw r4,0(fp) unsigned int base = sp->base; 801ac4: e0800017 ldw r2,0(fp) 801ac8: 10800017 ldw r2,0(r2) 801acc: e0800115 stw r2,4(fp) /* Mark the device as functional */ sp->broken = 0; 801ad0: e0800017 ldw r2,0(fp) 801ad4: 10000805 stb zero,32(r2) */ static ALT_INLINE int ALT_ALWAYS_INLINE alt_no_error (void) { return 0; 801ad8: e0000215 stw zero,8(fp) ALT_SEM_CREATE (&sp->write_lock, 1); /* TODO: check that usleep can be called in an initialization routine */ /* The initialisation sequence below is copied from the datasheet for * the 16207 LCD display. The first commands need to be timed because * the BUSY bit in the status register doesn't work until the display * has been reset three times. */ /* Wait for 15 ms then reset */ usleep(15000); 801adc: 010ea604 movi r4,15000 801ae0: 08027940 call 802794 <usleep> IOWR_ALTERA_AVALON_LCD_16207_COMMAND(base, LCD_CMD_FUNCTION_SET | LCD_CMD_8BIT); 801ae4: e0c00117 ldw r3,4(fp) 801ae8: 00800c04 movi r2,48 801aec: 18800035 stwio r2,0(r3) /* Wait for another 4.1ms and reset again */ usleep(4100); 801af0: 01040104 movi r4,4100 801af4: 08027940 call 802794 <usleep> IOWR_ALTERA_AVALON_LCD_16207_COMMAND(base, LCD_CMD_FUNCTION_SET | LCD_CMD_8BIT); 801af8: e0c00117 ldw r3,4(fp) 801afc: 00800c04 movi r2,48 801b00: 18800035 stwio r2,0(r3) /* Wait a further 1 ms and reset a third time */ usleep(1000); 801b04: 0100fa04 movi r4,1000 801b08: 08027940 call 802794 <usleep> IOWR_ALTERA_AVALON_LCD_16207_COMMAND(base, LCD_CMD_FUNCTION_SET | LCD_CMD_8BIT); 801b0c: e0c00117 ldw r3,4(fp) 801b10: 00800c04 movi r2,48 801b14: 18800035 stwio r2,0(r3) /* Setup interface parameters: 8 bit bus, 2 rows, 5x7 font */ lcd_write_command(sp, LCD_CMD_FUNCTION_SET | LCD_CMD_8BIT | LCD_CMD_TWO_LINE); 801b18: e1000017 ldw r4,0(fp) 801b1c: 01400e04 movi r5,56 801b20: 0800ec80 call 800ec8 <lcd_write_command> /* Turn display off */ lcd_write_command(sp, LCD_CMD_ONOFF); 801b24: e1000017 ldw r4,0(fp) 801b28: 01400204 movi r5,8 801b2c: 0800ec80 call 800ec8 <lcd_write_command> /* Clear display */ lcd_clear_screen(sp); 801b30: e1000017 ldw r4,0(fp) 801b34: 08010340 call 801034 <lcd_clear_screen> /* Set mode: increment after writing, don't shift display */ lcd_write_command(sp, LCD_CMD_MODES | LCD_CMD_MODE_INC); 801b38: e1000017 ldw r4,0(fp) 801b3c: 01400184 movi r5,6 801b40: 0800ec80 call 800ec8 <lcd_write_command> /* Turn display on */ lcd_write_command(sp, LCD_CMD_ONOFF | LCD_CMD_ENABLE_DISP); 801b44: e1000017 ldw r4,0(fp) 801b48: 01400304 movi r5,12 801b4c: 0800ec80 call 800ec8 <lcd_write_command> sp->esccount = -1; 801b50: e0c00017 ldw r3,0(fp) 801b54: 00bfffc4 movi r2,-1 801b58: 18800905 stb r2,36(r3) memset(sp->escape, 0, sizeof(sp->escape)); 801b5c: e0800017 ldw r2,0(fp) 801b60: 11000a04 addi r4,r2,40 801b64: 000b883a mov r5,zero 801b68: 01800204 movi r6,8 801b6c: 08035400 call 803540 <memset> sp->scrollpos = 0; 801b70: e0800017 ldw r2,0(fp) 801b74: 10000945 stb zero,37(r2) sp->scrollmax = 0; 801b78: e0800017 ldw r2,0(fp) 801b7c: 10000985 stb zero,38(r2) sp->active = 0; 801b80: e0800017 ldw r2,0(fp) 801b84: 100009c5 stb zero,39(r2) sp->period = alt_ticks_per_second() / 10; /* Call every 100ms */ 801b88: e4000017 ldw r16,0(fp) */ static ALT_INLINE alt_u32 ALT_ALWAYS_INLINE alt_ticks_per_second (void) { return _alt_tick_rate; 801b8c: d0a00e17 ldw r2,-32712(gp) 801b90: e0800315 stw r2,12(fp) 801b94: e1000317 ldw r4,12(fp) 801b98: 01400284 movi r5,10 801b9c: 0803b5c0 call 803b5c <__udivsi3> 801ba0: 80800715 stw r2,28(r16) alt_alarm_start(&sp->alarm, sp->period, &alt_lcd_16207_timeout, sp); 801ba4: e0800017 ldw r2,0(fp) 801ba8: 11000104 addi r4,r2,4 801bac: e0800017 ldw r2,0(fp) 801bb0: 11400717 ldw r5,28(r2) 801bb4: 01802034 movhi r6,128 801bb8: 31868604 addi r6,r6,6680 801bbc: e1c00017 ldw r7,0(fp) 801bc0: 0801ce00 call 801ce0 <alt_alarm_start> } 801bc4: dfc00617 ldw ra,24(sp) 801bc8: df000517 ldw fp,20(sp) 801bcc: dc000417 ldw r16,16(sp) 801bd0: dec00704 addi sp,sp,28 801bd4: f800283a ret 00801bd8 <altera_avalon_lcd_16207_write_fd>: const char* ptr, int count, int flags); int altera_avalon_lcd_16207_write_fd(alt_fd* fd, const char* buffer, int space) { 801bd8: defffa04 addi sp,sp,-24 801bdc: dfc00515 stw ra,20(sp) 801be0: df000415 stw fp,16(sp) 801be4: d839883a mov fp,sp 801be8: e1000015 stw r4,0(fp) 801bec: e1400115 stw r5,4(fp) 801bf0: e1800215 stw r6,8(fp) altera_avalon_lcd_16207_dev* dev = (altera_avalon_lcd_16207_dev*) fd->dev; 801bf4: e0800017 ldw r2,0(fp) 801bf8: 10800017 ldw r2,0(r2) 801bfc: e0800315 stw r2,12(fp) return altera_avalon_lcd_16207_write(&dev->state, buffer, space, 801c00: e0800317 ldw r2,12(fp) 801c04: 11000a04 addi r4,r2,40 801c08: e0800017 ldw r2,0(fp) 801c0c: e1400117 ldw r5,4(fp) 801c10: e1800217 ldw r6,8(fp) 801c14: 11c00217 ldw r7,8(r2) 801c18: 08015a80 call 8015a8 <altera_avalon_lcd_16207_write> fd->fd_flags); } 801c1c: dfc00517 ldw ra,20(sp) 801c20: df000417 ldw fp,16(sp) 801c24: dec00604 addi sp,sp,24 801c28: f800283a ret 00801c2c <alt_avalon_timer_sc_irq>: * alarms, see alt_tick.c for further details. */ static void alt_avalon_timer_sc_irq (void* base, alt_u32 id) { 801c2c: defffc04 addi sp,sp,-16 801c30: dfc00315 stw ra,12(sp) 801c34: df000215 stw fp,8(sp) 801c38: d839883a mov fp,sp 801c3c: e1000015 stw r4,0(fp) 801c40: e1400115 stw r5,4(fp) /* clear the interrupt */ IOWR_ALTERA_AVALON_TIMER_STATUS (base, 0); 801c44: e0800017 ldw r2,0(fp) 801c48: 10000035 stwio zero,0(r2) /* ALT_LOG - see altera_hal/HAL/inc/sys/alt_log_printf.h */ ALT_LOG_SYS_CLK_HEARTBEAT(); /* notify the system of a clock tick */ alt_tick (); 801c4c: 08026940 call 802694 <alt_tick> } 801c50: dfc00317 ldw ra,12(sp) 801c54: df000217 ldw fp,8(sp) 801c58: dec00404 addi sp,sp,16 801c5c: f800283a ret 00801c60 <alt_avalon_timer_sc_init>: /* * alt_avalon_timer_sc_init() is called to initialise the timer that will be * used to provide the periodic system clock. This is called from the * auto-generated alt_sys_init() function. */ void alt_avalon_timer_sc_init (void* base, alt_u32 irq, alt_u32 freq) { 801c60: defff904 addi sp,sp,-28 801c64: dfc00615 stw ra,24(sp) 801c68: df000515 stw fp,20(sp) 801c6c: d839883a mov fp,sp 801c70: e1000015 stw r4,0(fp) 801c74: e1400115 stw r5,4(fp) 801c78: e1800215 stw r6,8(fp) * in order to initialise the value of the clock frequency. */ static ALT_INLINE int ALT_ALWAYS_INLINE alt_sysclk_init (alt_u32 nticks) { 801c7c: e0800217 ldw r2,8(fp) 801c80: e0800315 stw r2,12(fp) if (! _alt_tick_rate) 801c84: d0a00e17 ldw r2,-32712(gp) 801c88: 1004c03a cmpne r2,r2,zero 801c8c: 1000041e bne r2,zero,801ca0 <alt_avalon_timer_sc_init+0x40> { _alt_tick_rate = nticks; 801c90: e0800317 ldw r2,12(fp) 801c94: d0a00e15 stw r2,-32712(gp) 801c98: e0000415 stw zero,16(fp) 801c9c: 00000206 br 801ca8 <alt_avalon_timer_sc_init+0x48> return 0; } else { return -1; 801ca0: 00bfffc4 movi r2,-1 801ca4: e0800415 stw r2,16(fp) /* set the system clock frequency */ alt_sysclk_init (freq); /* set to free running mode */ IOWR_ALTERA_AVALON_TIMER_CONTROL (base, 801ca8: e0800017 ldw r2,0(fp) 801cac: 10800104 addi r2,r2,4 801cb0: 1007883a mov r3,r2 801cb4: 008001c4 movi r2,7 801cb8: 18800035 stwio r2,0(r3) ALTERA_AVALON_TIMER_CONTROL_ITO_MSK | ALTERA_AVALON_TIMER_CONTROL_CONT_MSK | ALTERA_AVALON_TIMER_CONTROL_START_MSK); /* register the interrupt handler, and enable the interrupt */ alt_irq_register (irq, base, alt_avalon_timer_sc_irq); 801cbc: e1000117 ldw r4,4(fp) 801cc0: e1400017 ldw r5,0(fp) 801cc4: 01802034 movhi r6,128 801cc8: 31870b04 addi r6,r6,7212 801ccc: 08021980 call 802198 <alt_irq_register> } 801cd0: dfc00617 ldw ra,24(sp) 801cd4: df000517 ldw fp,20(sp) 801cd8: dec00704 addi sp,sp,28 801cdc: f800283a ret 00801ce0 <alt_alarm_start>: int alt_alarm_start (alt_alarm* alarm, alt_u32 nticks, alt_u32 (*callback) (void* context), void* context) { 801ce0: defff504 addi sp,sp,-44 801ce4: df000a15 stw fp,40(sp) 801ce8: d839883a mov fp,sp 801cec: e1000015 stw r4,0(fp) 801cf0: e1400115 stw r5,4(fp) 801cf4: e1800215 stw r6,8(fp) 801cf8: e1c00315 stw r7,12(fp) alt_irq_context irq_context; alt_u32 current_nticks = 0; 801cfc: e0000515 stw zero,20(fp) */ static ALT_INLINE alt_u32 ALT_ALWAYS_INLINE alt_ticks_per_second (void) { return _alt_tick_rate; 801d00: d0a00e17 ldw r2,-32712(gp) 801d04: e0800615 stw r2,24(fp) 801d08: e0800617 ldw r2,24(fp) 801d0c: 1005003a cmpeq r2,r2,zero 801d10: 10003f1e bne r2,zero,801e10 <alt_alarm_start+0x130> if (alt_ticks_per_second ()) { if (alarm) 801d14: e0800017 ldw r2,0(fp) 801d18: 1005003a cmpeq r2,r2,zero 801d1c: 1000391e bne r2,zero,801e04 <alt_alarm_start+0x124> { alarm->callback = callback; 801d20: e0c00017 ldw r3,0(fp) 801d24: e0800217 ldw r2,8(fp) 801d28: 18800315 stw r2,12(r3) alarm->context = context; 801d2c: e0c00017 ldw r3,0(fp) 801d30: e0800317 ldw r2,12(fp) 801d34: 18800515 stw r2,20(r3) alt_irq_disable_all (void) { alt_irq_context context; NIOS2_READ_STATUS (context); 801d38: 0005303a rdctl r2,status 801d3c: e0800815 stw r2,32(fp) NIOS2_WRITE_STATUS (0); 801d40: 0001703a wrctl status,zero 801d44: e0800817 ldw r2,32(fp) 801d48: e0800715 stw r2,28(fp) 801d4c: e0800717 ldw r2,28(fp) 801d50: e0800415 stw r2,16(fp) */ static ALT_INLINE alt_u32 ALT_ALWAYS_INLINE alt_nticks (void) { return _alt_nticks; 801d54: d0a00f17 ldw r2,-32708(gp) 801d58: e0800815 stw r2,32(fp) 801d5c: e0800817 ldw r2,32(fp) 801d60: e0800515 stw r2,20(fp) irq_context = alt_irq_disable_all (); current_nticks = alt_nticks(); alarm->time = nticks + current_nticks + 1; 801d64: e1000017 ldw r4,0(fp) 801d68: e0c00117 ldw r3,4(fp) 801d6c: e0800517 ldw r2,20(fp) 801d70: 1885883a add r2,r3,r2 801d74: 10800044 addi r2,r2,1 801d78: 20800215 stw r2,8(r4) /* * If the desired alarm time causes a roll-over, set the rollover * flag. This will prevent the subsequent tick event from causing * an alarm too early. */ if(alarm->time < current_nticks) 801d7c: e0800017 ldw r2,0(fp) 801d80: 10c00217 ldw r3,8(r2) 801d84: e0800517 ldw r2,20(fp) 801d88: 1880042e bgeu r3,r2,801d9c <alt_alarm_start+0xbc> { alarm->rollover = 1; 801d8c: e0c00017 ldw r3,0(fp) 801d90: 00800044 movi r2,1 801d94: 18800405 stb r2,16(r3) 801d98: 00000206 br 801da4 <alt_alarm_start+0xc4> } else { alarm->rollover = 0; 801d9c: e0800017 ldw r2,0(fp) 801da0: 10000405 stb zero,16(r2) */ static ALT_INLINE void ALT_ALWAYS_INLINE alt_llist_insert(alt_llist* list, alt_llist* entry) { 801da4: d0a01004 addi r2,gp,-32704 801da8: e0800815 stw r2,32(fp) 801dac: e0800017 ldw r2,0(fp) 801db0: e0800715 stw r2,28(fp) entry->previous = list; 801db4: e0c00717 ldw r3,28(fp) 801db8: e0800817 ldw r2,32(fp) 801dbc: 18800115 stw r2,4(r3) entry->next = list->next; 801dc0: e0c00717 ldw r3,28(fp) 801dc4: e0800817 ldw r2,32(fp) 801dc8: 10800017 ldw r2,0(r2) 801dcc: 18800015 stw r2,0(r3) list->next->previous = entry; 801dd0: e0800817 ldw r2,32(fp) 801dd4: 10c00017 ldw r3,0(r2) 801dd8: e0800717 ldw r2,28(fp) 801ddc: 18800115 stw r2,4(r3) list->next = entry; 801de0: e0c00817 ldw r3,32(fp) 801de4: e0800717 ldw r2,28(fp) 801de8: 18800015 stw r2,0(r3) */ static ALT_INLINE void ALT_ALWAYS_INLINE alt_irq_enable_all (alt_irq_context context) { 801dec: e0800417 ldw r2,16(fp) 801df0: e0800815 stw r2,32(fp) NIOS2_WRITE_STATUS (context); 801df4: e0800817 ldw r2,32(fp) 801df8: 1001703a wrctl status,r2 } alt_llist_insert (&alt_alarm_list, &alarm->llist); alt_irq_enable_all (irq_context); return 0; 801dfc: e0000915 stw zero,36(fp) 801e00: 00000506 br 801e18 <alt_alarm_start+0x138> } else { return -EINVAL; 801e04: 00bffa84 movi r2,-22 801e08: e0800915 stw r2,36(fp) 801e0c: 00000206 br 801e18 <alt_alarm_start+0x138> } } else { return -ENOTSUP; 801e10: 00bfde84 movi r2,-134 801e14: e0800915 stw r2,36(fp) } } 801e18: e0800917 ldw r2,36(fp) 801e1c: df000a17 ldw fp,40(sp) 801e20: dec00b04 addi sp,sp,44 801e24: f800283a ret 00801e28 <alt_dcache_flush_all>: * alt_dcache_flush_all() is called to flush the entire data cache. */ void alt_dcache_flush_all (void) { 801e28: defffe04 addi sp,sp,-8 801e2c: df000115 stw fp,4(sp) 801e30: d839883a mov fp,sp #if NIOS2_DCACHE_SIZE > 0 char* i; for (i = (char*) 0; i < (char*) NIOS2_DCACHE_SIZE; i+= NIOS2_DCACHE_LINE_SIZE) 801e34: e0000015 stw zero,0(fp) 801e38: e0800017 ldw r2,0(fp) 801e3c: 10820028 cmpgeui r2,r2,2048 801e40: 1000061e bne r2,zero,801e5c <alt_dcache_flush_all+0x34> { __asm__ volatile ("flushd (%0)" :: "r" (i)); 801e44: e0800017 ldw r2,0(fp) 801e48: 1000003b flushd 0(r2) 801e4c: e0800017 ldw r2,0(fp) 801e50: 10800804 addi r2,r2,32 801e54: e0800015 stw r2,0(fp) 801e58: 003ff706 br 801e38 <alt_dcache_flush_all+0x10> } #endif /* NIOS2_DCACHE_SIZE > 0 */ } 801e5c: df000117 ldw fp,4(sp) 801e60: dec00204 addi sp,sp,8 801e64: f800283a ret 00801e68 <alt_dev_null_write>: * indicates that the data has been successfully transmitted. */ static int alt_dev_null_write (alt_fd* fd, const char* ptr, int len) { 801e68: defffc04 addi sp,sp,-16 801e6c: df000315 stw fp,12(sp) 801e70: d839883a mov fp,sp 801e74: e1000015 stw r4,0(fp) 801e78: e1400115 stw r5,4(fp) 801e7c: e1800215 stw r6,8(fp) return len; 801e80: e0800217 ldw r2,8(fp) } 801e84: df000317 ldw fp,12(sp) 801e88: dec00404 addi sp,sp,16 801e8c: f800283a ret 00801e90 <alt_dev_llist_insert>: * */ int alt_dev_llist_insert (alt_dev_llist* dev, alt_llist* list) { 801e90: defff904 addi sp,sp,-28 801e94: dfc00615 stw ra,24(sp) 801e98: df000515 stw fp,20(sp) 801e9c: d839883a mov fp,sp 801ea0: e1000015 stw r4,0(fp) 801ea4: e1400115 stw r5,4(fp) /* * check that the device exists, and that it has a valid name. */ if (!dev || !dev->name) 801ea8: e0800017 ldw r2,0(fp) 801eac: 1005003a cmpeq r2,r2,zero 801eb0: 1000041e bne r2,zero,801ec4 <alt_dev_llist_insert+0x34> 801eb4: e0800017 ldw r2,0(fp) 801eb8: 10800217 ldw r2,8(r2) 801ebc: 1004c03a cmpne r2,r2,zero 801ec0: 1000071e bne r2,zero,801ee0 <alt_dev_llist_insert+0x50> { ALT_ERRNO = EINVAL; 801ec4: 0801f400 call 801f40 <alt_get_errno> 801ec8: 1007883a mov r3,r2 801ecc: 00800584 movi r2,22 801ed0: 18800015 stw r2,0(r3) return -EINVAL; 801ed4: 00bffa84 movi r2,-22 801ed8: e0800415 stw r2,16(fp) 801edc: 00001306 br 801f2c <alt_dev_llist_insert+0x9c> */ static ALT_INLINE void ALT_ALWAYS_INLINE alt_llist_insert(alt_llist* list, alt_llist* entry) { 801ee0: e0800117 ldw r2,4(fp) 801ee4: e0800215 stw r2,8(fp) 801ee8: e0800017 ldw r2,0(fp) 801eec: e0800315 stw r2,12(fp) entry->previous = list; 801ef0: e0c00317 ldw r3,12(fp) 801ef4: e0800217 ldw r2,8(fp) 801ef8: 18800115 stw r2,4(r3) entry->next = list->next; 801efc: e0c00317 ldw r3,12(fp) 801f00: e0800217 ldw r2,8(fp) 801f04: 10800017 ldw r2,0(r2) 801f08: 18800015 stw r2,0(r3) list->next->previous = entry; 801f0c: e0800217 ldw r2,8(fp) 801f10: 10c00017 ldw r3,0(r2) 801f14: e0800317 ldw r2,12(fp) 801f18: 18800115 stw r2,4(r3) list->next = entry; 801f1c: e0c00217 ldw r3,8(fp) 801f20: e0800317 ldw r2,12(fp) 801f24: 18800015 stw r2,0(r3) } /* * register the device. */ alt_llist_insert(list, &dev->llist); return 0; 801f28: e0000415 stw zero,16(fp) } 801f2c: e0800417 ldw r2,16(fp) 801f30: dfc00617 ldw ra,24(sp) 801f34: df000517 ldw fp,20(sp) 801f38: dec00704 addi sp,sp,28 801f3c: f800283a ret 00801f40 <alt_get_errno>: extern int errno; static ALT_INLINE int* alt_get_errno(void) { 801f40: defffd04 addi sp,sp,-12 801f44: dfc00215 stw ra,8(sp) 801f48: df000115 stw fp,4(sp) 801f4c: d839883a mov fp,sp return ((alt_errno) ? alt_errno() : &errno); 801f50: d0a00b17 ldw r2,-32724(gp) 801f54: 1005003a cmpeq r2,r2,zero 801f58: 1000041e bne r2,zero,801f6c <alt_get_errno+0x2c> 801f5c: d0a00b17 ldw r2,-32724(gp) 801f60: 103ee83a callr r2 801f64: e0800015 stw r2,0(fp) 801f68: 00000206 br 801f74 <alt_get_errno+0x34> 801f6c: d0a01b04 addi r2,gp,-32660 801f70: e0800015 stw r2,0(fp) 801f74: e0800017 ldw r2,0(fp) } 801f78: dfc00217 ldw ra,8(sp) 801f7c: df000117 ldw fp,4(sp) 801f80: dec00304 addi sp,sp,12 801f84: f800283a ret 00801f88 <_do_ctors>: * Run the C++ static constructors. */ void _do_ctors(void) { 801f88: defffd04 addi sp,sp,-12 801f8c: dfc00215 stw ra,8(sp) 801f90: df000115 stw fp,4(sp) 801f94: d839883a mov fp,sp constructor* ctor; for (ctor = &__CTOR_END__[-1]; ctor >= __CTOR_LIST__; ctor--) 801f98: 00802034 movhi r2,128 801f9c: 108f2d04 addi r2,r2,15540 801fa0: e0800015 stw r2,0(fp) 801fa4: e0c00017 ldw r3,0(fp) 801fa8: 00802034 movhi r2,128 801fac: 108f2e04 addi r2,r2,15544 801fb0: 18800736 bltu r3,r2,801fd0 <_do_ctors+0x48> (*ctor) (); 801fb4: e0800017 ldw r2,0(fp) 801fb8: 10800017 ldw r2,0(r2) 801fbc: 103ee83a callr r2 801fc0: e0800017 ldw r2,0(fp) 801fc4: 10bfff04 addi r2,r2,-4 801fc8: e0800015 stw r2,0(fp) 801fcc: 003ff506 br 801fa4 <_do_ctors+0x1c> } 801fd0: dfc00217 ldw ra,8(sp) 801fd4: df000117 ldw fp,4(sp) 801fd8: dec00304 addi sp,sp,12 801fdc: f800283a ret 00801fe0 <_do_dtors>: * Run the C++ static destructors. */ void _do_dtors(void) { 801fe0: defffd04 addi sp,sp,-12 801fe4: dfc00215 stw ra,8(sp) 801fe8: df000115 stw fp,4(sp) 801fec: d839883a mov fp,sp destructor* dtor; for (dtor = &__DTOR_END__[-1]; dtor >= __DTOR_LIST__; dtor--) 801ff0: 00802034 movhi r2,128 801ff4: 108f2d04 addi r2,r2,15540 801ff8: e0800015 stw r2,0(fp) 801ffc: e0c00017 ldw r3,0(fp) 802000: 00802034 movhi r2,128 802004: 108f2e04 addi r2,r2,15544 802008: 18800736 bltu r3,r2,802028 <_do_dtors+0x48> (*dtor) (); 80200c: e0800017 ldw r2,0(fp) 802010: 10800017 ldw r2,0(r2) 802014: 103ee83a callr r2 802018: e0800017 ldw r2,0(fp) 80201c: 10bfff04 addi r2,r2,-4 802020: e0800015 stw r2,0(fp) 802024: 003ff506 br 801ffc <_do_dtors+0x1c> } 802028: dfc00217 ldw ra,8(sp) 80202c: df000117 ldw fp,4(sp) 802030: dec00304 addi sp,sp,12 802034: f800283a ret 00802038 <alt_icache_flush_all>: * alt_icache_flush_all() is called to flush the entire instruction cache. */ void alt_icache_flush_all (void) { 802038: defffe04 addi sp,sp,-8 80203c: dfc00115 stw ra,4(sp) 802040: df000015 stw fp,0(sp) 802044: d839883a mov fp,sp #if NIOS2_ICACHE_SIZE > 0 alt_icache_flush (0, NIOS2_ICACHE_SIZE); 802048: 0009883a mov r4,zero 80204c: 01440004 movi r5,4096 802050: 0802b280 call 802b28 <alt_icache_flush> #endif } 802054: dfc00117 ldw ra,4(sp) 802058: df000017 ldw fp,0(sp) 80205c: dec00204 addi sp,sp,8 802060: f800283a ret 00802064 <alt_open_fd>: * remains unchanged. */ static void alt_open_fd(alt_fd* fd, const char* name, int flags, int mode) { 802064: defff904 addi sp,sp,-28 802068: dfc00615 stw ra,24(sp) 80206c: df000515 stw fp,20(sp) 802070: d839883a mov fp,sp 802074: e1000015 stw r4,0(fp) 802078: e1400115 stw r5,4(fp) 80207c: e1800215 stw r6,8(fp) 802080: e1c00315 stw r7,12(fp) int old; old = open (name, flags, mode); 802084: e1000117 ldw r4,4(fp) 802088: e1400217 ldw r5,8(fp) 80208c: e1800317 ldw r6,12(fp) 802090: 08023e00 call 8023e0 <open> 802094: e0800415 stw r2,16(fp) if (old >= 0) 802098: e0800417 ldw r2,16(fp) 80209c: 1004803a cmplt r2,r2,zero 8020a0: 10001c1e bne r2,zero,802114 <alt_open_fd+0xb0> { fd->dev = alt_fd_list[old].dev; 8020a4: e1000017 ldw r4,0(fp) 8020a8: 00c02034 movhi r3,128 8020ac: 18d40704 addi r3,r3,20508 8020b0: e0800417 ldw r2,16(fp) 8020b4: 10800324 muli r2,r2,12 8020b8: 10c5883a add r2,r2,r3 8020bc: 10800017 ldw r2,0(r2) 8020c0: 20800015 stw r2,0(r4) fd->priv = alt_fd_list[old].priv; 8020c4: e1000017 ldw r4,0(fp) 8020c8: 00c02034 movhi r3,128 8020cc: 18d40704 addi r3,r3,20508 8020d0: e0800417 ldw r2,16(fp) 8020d4: 10800324 muli r2,r2,12 8020d8: 10c5883a add r2,r2,r3 8020dc: 10800104 addi r2,r2,4 8020e0: 10800017 ldw r2,0(r2) 8020e4: 20800115 stw r2,4(r4) fd->fd_flags = alt_fd_list[old].fd_flags; 8020e8: e1000017 ldw r4,0(fp) 8020ec: 00c02034 movhi r3,128 8020f0: 18d40704 addi r3,r3,20508 8020f4: e0800417 ldw r2,16(fp) 8020f8: 10800324 muli r2,r2,12 8020fc: 10c5883a add r2,r2,r3 802100: 10800204 addi r2,r2,8 802104: 10800017 ldw r2,0(r2) 802108: 20800215 stw r2,8(r4) alt_release_fd (old); 80210c: e1000417 ldw r4,16(fp) 802110: 08025a80 call 8025a8 <alt_release_fd> } } 802114: dfc00617 ldw ra,24(sp) 802118: df000517 ldw fp,20(sp) 80211c: dec00704 addi sp,sp,28 802120: f800283a ret 00802124 <alt_io_redirect>: /* * alt_io_redirect() is called once the device/filesystem lists have been * initialised, but before main(). Its function is to redirect standard in, * standard out and standard error so that they point to the devices selected by * the user (as defined in system.h). * * Prior to the call to this function, io is directed towards /dev/null. If * i/o can not be redirected to the requested device, for example if the device * does not exist, then it remains directed at /dev/null. */ void alt_io_redirect(const char* stdout_dev, const char* stdin_dev, const char* stderr_dev) { 802124: defffb04 addi sp,sp,-20 802128: dfc00415 stw ra,16(sp) 80212c: df000315 stw fp,12(sp) 802130: d839883a mov fp,sp 802134: e1000015 stw r4,0(fp) 802138: e1400115 stw r5,4(fp) 80213c: e1800215 stw r6,8(fp) /* Redirect the channels */ alt_open_fd (&alt_fd_list[STDOUT_FILENO], stdout_dev, O_WRONLY, 0777); 802140: 01002034 movhi r4,128 802144: 21140a04 addi r4,r4,20520 802148: e1400017 ldw r5,0(fp) 80214c: 01800044 movi r6,1 802150: 01c07fc4 movi r7,511 802154: 08020640 call 802064 <alt_open_fd> alt_open_fd (&alt_fd_list[STDIN_FILENO], stdin_dev, O_RDONLY, 0777); 802158: 01002034 movhi r4,128 80215c: 21140704 addi r4,r4,20508 802160: e1400117 ldw r5,4(fp) 802164: 000d883a mov r6,zero 802168: 01c07fc4 movi r7,511 80216c: 08020640 call 802064 <alt_open_fd> alt_open_fd (&alt_fd_list[STDERR_FILENO], stderr_dev, O_WRONLY, 0777); 802170: 01002034 movhi r4,128 802174: 21140d04 addi r4,r4,20532 802178: e1400217 ldw r5,8(fp) 80217c: 01800044 movi r6,1 802180: 01c07fc4 movi r7,511 802184: 08020640 call 802064 <alt_open_fd> } 802188: dfc00417 ldw ra,16(sp) 80218c: df000317 ldw fp,12(sp) 802190: dec00504 addi sp,sp,20 802194: f800283a ret 00802198 <alt_irq_register>: int alt_irq_register (alt_u32 id, void* context, void (*handler)(void*, alt_u32)) { 802198: defff304 addi sp,sp,-52 80219c: df000c15 stw fp,48(sp) 8021a0: d839883a mov fp,sp 8021a4: e1000015 stw r4,0(fp) 8021a8: e1400115 stw r5,4(fp) 8021ac: e1800215 stw r6,8(fp) int rc = -EINVAL; 8021b0: 00bffa84 movi r2,-22 8021b4: e0800315 stw r2,12(fp) alt_irq_context status; if (id < ALT_NIRQ) 8021b8: e0800017 ldw r2,0(fp) 8021bc: 10800828 cmpgeui r2,r2,32 8021c0: 1000511e bne r2,zero,802308 <alt_irq_register+0x170> alt_irq_disable_all (void) { alt_irq_context context; NIOS2_READ_STATUS (context); 8021c4: 0005303a rdctl r2,status 8021c8: e0800615 stw r2,24(fp) NIOS2_WRITE_STATUS (0); 8021cc: 0001703a wrctl status,zero 8021d0: e0800617 ldw r2,24(fp) 8021d4: e0800515 stw r2,20(fp) 8021d8: e0800517 ldw r2,20(fp) 8021dc: e0800415 stw r2,16(fp) { /* * interrupts are disabled while the handler tables are updated to ensure * that an interrupt doesn't occur while the tables are in an inconsistant * state. */ status = alt_irq_disable_all (); alt_irq[id].handler = handler; 8021e0: 00c02034 movhi r3,128 8021e4: 18d66e04 addi r3,r3,22968 8021e8: e0800017 ldw r2,0(fp) 8021ec: 10800224 muli r2,r2,8 8021f0: 10c7883a add r3,r2,r3 8021f4: e0800217 ldw r2,8(fp) 8021f8: 18800015 stw r2,0(r3) alt_irq[id].context = context; 8021fc: 00c02034 movhi r3,128 802200: 18d66e04 addi r3,r3,22968 802204: e0800017 ldw r2,0(fp) 802208: 10800224 muli r2,r2,8 80220c: 10c5883a add r2,r2,r3 802210: 10c00104 addi r3,r2,4 802214: e0800117 ldw r2,4(fp) 802218: 18800015 stw r2,0(r3) rc = (handler) ? alt_irq_enable (id): alt_irq_disable (id); 80221c: e0800217 ldw r2,8(fp) 802220: 1005003a cmpeq r2,r2,zero 802224: 1000191e bne r2,zero,80228c <alt_irq_register+0xf4> * */ static ALT_INLINE int ALT_ALWAYS_INLINE alt_irq_enable (alt_u32 id) { 802228: e0800017 ldw r2,0(fp) 80222c: e0800615 stw r2,24(fp) 802230: 0005303a rdctl r2,status 802234: e0800915 stw r2,36(fp) 802238: 0001703a wrctl status,zero 80223c: e0800917 ldw r2,36(fp) 802240: e0800815 stw r2,32(fp) 802244: e0800817 ldw r2,32(fp) 802248: e0800715 stw r2,28(fp) alt_irq_context status; extern volatile alt_u32 alt_irq_active; status = alt_irq_disable_all (); alt_irq_active |= (1 << id); 80224c: 00c00044 movi r3,1 802250: e0800617 ldw r2,24(fp) 802254: 1886983a sll r3,r3,r2 802258: d0a00c17 ldw r2,-32720(gp) 80225c: 10c4b03a or r2,r2,r3 802260: d0a00c15 stw r2,-32720(gp) NIOS2_WRITE_IENABLE (alt_irq_active); 802264: d0a00c17 ldw r2,-32720(gp) 802268: 100170fa wrctl ienable,r2 80226c: e0800717 ldw r2,28(fp) 802270: e0800915 stw r2,36(fp) 802274: e0800917 ldw r2,36(fp) 802278: 1001703a wrctl status,r2 alt_irq_enable_all(status); 80227c: e0000515 stw zero,20(fp) 802280: e0800517 ldw r2,20(fp) 802284: e0800b15 stw r2,44(fp) 802288: 00001906 br 8022f0 <alt_irq_register+0x158> 80228c: e0800017 ldw r2,0(fp) 802290: e0800915 stw r2,36(fp) 802294: 0005303a rdctl r2,status 802298: e0800a15 stw r2,40(fp) 80229c: 0001703a wrctl status,zero 8022a0: e0800a17 ldw r2,40(fp) 8022a4: e0800615 stw r2,24(fp) 8022a8: e0800617 ldw r2,24(fp) 8022ac: e0800715 stw r2,28(fp) 8022b0: 00c00044 movi r3,1 8022b4: e0800917 ldw r2,36(fp) 8022b8: 1884983a sll r2,r3,r2 8022bc: 0086303a nor r3,zero,r2 8022c0: d0a00c17 ldw r2,-32720(gp) 8022c4: 10c4703a and r2,r2,r3 8022c8: d0a00c15 stw r2,-32720(gp) 8022cc: d0a00c17 ldw r2,-32720(gp) 8022d0: 100170fa wrctl ienable,r2 8022d4: e0800717 ldw r2,28(fp) 8022d8: e0800a15 stw r2,40(fp) 8022dc: e0800a17 ldw r2,40(fp) 8022e0: 1001703a wrctl status,r2 8022e4: e0000815 stw zero,32(fp) 8022e8: e0800817 ldw r2,32(fp) 8022ec: e0800b15 stw r2,44(fp) 8022f0: e0800b17 ldw r2,44(fp) 8022f4: e0800315 stw r2,12(fp) 8022f8: e0800417 ldw r2,16(fp) 8022fc: e0800a15 stw r2,40(fp) 802300: e0800a17 ldw r2,40(fp) 802304: 1001703a wrctl status,r2 alt_irq_enable_all(status); } return rc; 802308: e0800317 ldw r2,12(fp) } 80230c: df000c17 ldw fp,48(sp) 802310: dec00d04 addi sp,sp,52 802314: f800283a ret 00802318 <alt_file_locked>: * themselves, and report the error from the filesystems open() function. */ static int alt_file_locked (alt_fd* fd) { 802318: defffc04 addi sp,sp,-16 80231c: df000315 stw fp,12(sp) 802320: d839883a mov fp,sp 802324: e1000015 stw r4,0(fp) alt_u32 i; /* * Mark the file descriptor as belonging to a device. */ fd->fd_flags |= ALT_FD_DEV; 802328: e0c00017 ldw r3,0(fp) 80232c: e0800017 ldw r2,0(fp) 802330: 10800217 ldw r2,8(r2) 802334: 10900034 orhi r2,r2,16384 802338: 18800215 stw r2,8(r3) /* * Loop through all current file descriptors searching for one that's locked * for exclusive access. If a match is found, generate an error. */ for (i = 0; i <= alt_max_fd; i++) 80233c: e0000115 stw zero,4(fp) 802340: d0e00a17 ldw r3,-32728(gp) 802344: e0800117 ldw r2,4(fp) 802348: 18802036 bltu r3,r2,8023cc <alt_file_locked+0xb4> { if ((alt_fd_list[i].dev == fd->dev) && 80234c: 00c02034 movhi r3,128 802350: 18d40704 addi r3,r3,20508 802354: e0800117 ldw r2,4(fp) 802358: 10800324 muli r2,r2,12 80235c: 10c5883a add r2,r2,r3 802360: e0c00017 ldw r3,0(fp) 802364: 11000017 ldw r4,0(r2) 802368: 18800017 ldw r2,0(r3) 80236c: 2080131e bne r4,r2,8023bc <alt_file_locked+0xa4> 802370: 00c02034 movhi r3,128 802374: 18d40704 addi r3,r3,20508 802378: e0800117 ldw r2,4(fp) 80237c: 10800324 muli r2,r2,12 802380: 10c5883a add r2,r2,r3 802384: 10800204 addi r2,r2,8 802388: 10800017 ldw r2,0(r2) 80238c: 1004403a cmpge r2,r2,zero 802390: 10000a1e bne r2,zero,8023bc <alt_file_locked+0xa4> 802394: e0800117 ldw r2,4(fp) 802398: 10c00324 muli r3,r2,12 80239c: 00802034 movhi r2,128 8023a0: 10940704 addi r2,r2,20508 8023a4: 1887883a add r3,r3,r2 8023a8: e0800017 ldw r2,0(fp) 8023ac: 18800326 beq r3,r2,8023bc <alt_file_locked+0xa4> (alt_fd_list[i].fd_flags & ALT_FD_EXCL) && (&alt_fd_list[i] != fd)) { return -EACCES; 8023b0: 00bffcc4 movi r2,-13 8023b4: e0800215 stw r2,8(fp) 8023b8: 00000506 br 8023d0 <alt_file_locked+0xb8> 8023bc: e0800117 ldw r2,4(fp) 8023c0: 10800044 addi r2,r2,1 8023c4: e0800115 stw r2,4(fp) 8023c8: 003fdd06 br 802340 <alt_file_locked+0x28> } } /* The device is not locked */ return 0; 8023cc: e0000215 stw zero,8(fp) } 8023d0: e0800217 ldw r2,8(fp) 8023d4: df000317 ldw fp,12(sp) 8023d8: dec00404 addi sp,sp,16 8023dc: f800283a ret 008023e0 <open>: /* * open() is called in order to get a file descriptor that reference the file * or device named "name". This descriptor can then be used to manipulate the * file/device using the standard system calls, e.g. write(), read(), ioctl() * etc. * * This is equivalent to the standard open() system call. * * ALT_OPEN is mapped onto the open() system call in alt_syscall.h */ int ALT_OPEN (const char* file, int flags, int mode) { 8023e0: defff404 addi sp,sp,-48 8023e4: dfc00b15 stw ra,44(sp) 8023e8: df000a15 stw fp,40(sp) 8023ec: d839883a mov fp,sp 8023f0: e1000015 stw r4,0(fp) 8023f4: e1400115 stw r5,4(fp) 8023f8: e1800215 stw r6,8(fp) alt_dev* dev; alt_fd* fd; int index = -1; 8023fc: 00bfffc4 movi r2,-1 802400: e0800515 stw r2,20(fp) int status = -ENODEV; 802404: 00bffb44 movi r2,-19 802408: e0800615 stw r2,24(fp) int isafs = 0; 80240c: e0000715 stw zero,28(fp) /* * Check the device list, to see if a device with a matching name is * registered. */ if (!(dev = alt_find_dev (file, &alt_dev_list))) 802410: e1000017 ldw r4,0(fp) 802414: d1600804 addi r5,gp,-32736 802418: 08029080 call 802908 <alt_find_dev> 80241c: e0800315 stw r2,12(fp) 802420: e0800317 ldw r2,12(fp) 802424: 1004c03a cmpne r2,r2,zero 802428: 1000051e bne r2,zero,802440 <open+0x60> { /* No matching device, so try the filesystem list */ dev = alt_find_file (file); 80242c: e1000017 ldw r4,0(fp) 802430: 08029980 call 802998 <alt_find_file> 802434: e0800315 stw r2,12(fp) isafs = 1; 802438: 00800044 movi r2,1 80243c: e0800715 stw r2,28(fp) } /* * If a matching device or filesystem is found, allocate a file descriptor. */ if (dev) 802440: e0800317 ldw r2,12(fp) 802444: 1005003a cmpeq r2,r2,zero 802448: 1000301e bne r2,zero,80250c <open+0x12c> { if ((index = alt_get_fd (dev)) < 0) 80244c: e1000317 ldw r4,12(fp) 802450: 0802a7c0 call 802a7c <alt_get_fd> 802454: e0800515 stw r2,20(fp) 802458: e0800517 ldw r2,20(fp) 80245c: 1004403a cmpge r2,r2,zero 802460: 1000031e bne r2,zero,802470 <open+0x90> { status = index; 802464: e0800517 ldw r2,20(fp) 802468: e0800615 stw r2,24(fp) 80246c: 00002906 br 802514 <open+0x134> } else { fd = &alt_fd_list[index]; 802470: e0800517 ldw r2,20(fp) 802474: 10c00324 muli r3,r2,12 802478: 00802034 movhi r2,128 80247c: 10940704 addi r2,r2,20508 802480: 1885883a add r2,r3,r2 802484: e0800415 stw r2,16(fp) fd->fd_flags = (flags & ~ALT_FD_FLAGS_MASK); 802488: e1000417 ldw r4,16(fp) 80248c: e0c00117 ldw r3,4(fp) 802490: 00900034 movhi r2,16384 802494: 10bfffc4 addi r2,r2,-1 802498: 1884703a and r2,r3,r2 80249c: 20800215 stw r2,8(r4) /* If this is a device, ensure it isn't already locked */ if (isafs || ((status = alt_file_locked (fd)) >= 0)) 8024a0: e0800717 ldw r2,28(fp) 8024a4: 1004c03a cmpne r2,r2,zero 8024a8: 1000071e bne r2,zero,8024c8 <open+0xe8> 8024ac: e1000417 ldw r4,16(fp) 8024b0: 08023180 call 802318 <alt_file_locked> 8024b4: e0800615 stw r2,24(fp) 8024b8: e0800617 ldw r2,24(fp) 8024bc: 1004403a cmpge r2,r2,zero 8024c0: 1000011e bne r2,zero,8024c8 <open+0xe8> 8024c4: 00001306 br 802514 <open+0x134> { /* * If the device or filesystem provides an open() callback function, * call it now to perform any device/filesystem specific operations. */ status = (dev->open) ? dev->open(fd, file, flags, mode): 0; 8024c8: e0800317 ldw r2,12(fp) 8024cc: 10800317 ldw r2,12(r2) 8024d0: 1005003a cmpeq r2,r2,zero 8024d4: 1000091e bne r2,zero,8024fc <open+0x11c> 8024d8: e0800317 ldw r2,12(fp) 8024dc: 10800317 ldw r2,12(r2) 8024e0: e1000417 ldw r4,16(fp) 8024e4: e1400017 ldw r5,0(fp) 8024e8: e1800117 ldw r6,4(fp) 8024ec: e1c00217 ldw r7,8(fp) 8024f0: 103ee83a callr r2 8024f4: e0800915 stw r2,36(fp) 8024f8: 00000106 br 802500 <open+0x120> 8024fc: e0000915 stw zero,36(fp) 802500: e0800917 ldw r2,36(fp) 802504: e0800615 stw r2,24(fp) 802508: 00000206 br 802514 <open+0x134> } } } else { status = -ENODEV; 80250c: 00bffb44 movi r2,-19 802510: e0800615 stw r2,24(fp) } /* Allocation failed, so clean up and return an error */ if (status < 0) 802514: e0800617 ldw r2,24(fp) 802518: 1004403a cmpge r2,r2,zero 80251c: 1000091e bne r2,zero,802544 <open+0x164> { alt_release_fd (index); 802520: e1000517 ldw r4,20(fp) 802524: 08025a80 call 8025a8 <alt_release_fd> ALT_ERRNO = -status; 802528: 08025600 call 802560 <alt_get_errno> 80252c: e0c00617 ldw r3,24(fp) 802530: 00c7c83a sub r3,zero,r3 802534: 10c00015 stw r3,0(r2) return -1; 802538: 00bfffc4 movi r2,-1 80253c: e0800815 stw r2,32(fp) 802540: 00000206 br 80254c <open+0x16c> } /* return the reference upon success */ return index; 802544: e0800517 ldw r2,20(fp) 802548: e0800815 stw r2,32(fp) } 80254c: e0800817 ldw r2,32(fp) 802550: dfc00b17 ldw ra,44(sp) 802554: df000a17 ldw fp,40(sp) 802558: dec00c04 addi sp,sp,48 80255c: f800283a ret 00802560 <alt_get_errno>: extern int errno; static ALT_INLINE int* alt_get_errno(void) { 802560: defffd04 addi sp,sp,-12 802564: dfc00215 stw ra,8(sp) 802568: df000115 stw fp,4(sp) 80256c: d839883a mov fp,sp return ((alt_errno) ? alt_errno() : &errno); 802570: d0a00b17 ldw r2,-32724(gp) 802574: 1005003a cmpeq r2,r2,zero 802578: 1000041e bne r2,zero,80258c <alt_get_errno+0x2c> 80257c: d0a00b17 ldw r2,-32724(gp) 802580: 103ee83a callr r2 802584: e0800015 stw r2,0(fp) 802588: 00000206 br 802594 <alt_get_errno+0x34> 80258c: d0a01b04 addi r2,gp,-32660 802590: e0800015 stw r2,0(fp) 802594: e0800017 ldw r2,0(fp) } 802598: dfc00217 ldw ra,8(sp) 80259c: df000117 ldw fp,4(sp) 8025a0: dec00304 addi sp,sp,12 8025a4: f800283a ret 008025a8 <alt_release_fd>: * error cannont be released backed to the pool. They are always reserved. */ void alt_release_fd (int fd) { 8025a8: defffe04 addi sp,sp,-8 8025ac: df000115 stw fp,4(sp) 8025b0: d839883a mov fp,sp 8025b4: e1000015 stw r4,0(fp) if (fd > 2) 8025b8: e0800017 ldw r2,0(fp) 8025bc: 108000d0 cmplti r2,r2,3 8025c0: 10000d1e bne r2,zero,8025f8 <alt_release_fd+0x50> { alt_fd_list[fd].fd_flags = 0; 8025c4: 00c02034 movhi r3,128 8025c8: 18d40704 addi r3,r3,20508 8025cc: e0800017 ldw r2,0(fp) 8025d0: 10800324 muli r2,r2,12 8025d4: 10c5883a add r2,r2,r3 8025d8: 10800204 addi r2,r2,8 8025dc: 10000015 stw zero,0(r2) alt_fd_list[fd].dev = 0; 8025e0: 00c02034 movhi r3,128 8025e4: 18d40704 addi r3,r3,20508 8025e8: e0800017 ldw r2,0(fp) 8025ec: 10800324 muli r2,r2,12 8025f0: 10c5883a add r2,r2,r3 8025f4: 10000015 stw zero,0(r2) } } 8025f8: df000117 ldw fp,4(sp) 8025fc: dec00204 addi sp,sp,8 802600: f800283a ret 00802604 <alt_alarm_stop>: * the alarm executes. */ void alt_alarm_stop (alt_alarm* alarm) { 802604: defffb04 addi sp,sp,-20 802608: df000415 stw fp,16(sp) 80260c: d839883a mov fp,sp 802610: e1000015 stw r4,0(fp) alt_irq_disable_all (void) { alt_irq_context context; NIOS2_READ_STATUS (context); 802614: 0005303a rdctl r2,status 802618: e0800315 stw r2,12(fp) NIOS2_WRITE_STATUS (0); 80261c: 0001703a wrctl status,zero 802620: e0800317 ldw r2,12(fp) 802624: e0800215 stw r2,8(fp) 802628: e0800217 ldw r2,8(fp) 80262c: e0800115 stw r2,4(fp) * input argument is the element to remove. */ static ALT_INLINE void ALT_ALWAYS_INLINE alt_llist_remove(alt_llist* entry) { 802630: e0800017 ldw r2,0(fp) 802634: e0800315 stw r2,12(fp) entry->next->previous = entry->previous; 802638: e0800317 ldw r2,12(fp) 80263c: 10c00017 ldw r3,0(r2) 802640: e0800317 ldw r2,12(fp) 802644: 10800117 ldw r2,4(r2) 802648: 18800115 stw r2,4(r3) entry->previous->next = entry->next; 80264c: e0800317 ldw r2,12(fp) 802650: 10c00117 ldw r3,4(r2) 802654: e0800317 ldw r2,12(fp) 802658: 10800017 ldw r2,0(r2) 80265c: 18800015 stw r2,0(r3) /* * Set the entry to point to itself, so that any further calls to * alt_llist_remove() are harmless. */ entry->previous = entry; 802660: e0c00317 ldw r3,12(fp) 802664: e0800317 ldw r2,12(fp) 802668: 18800115 stw r2,4(r3) entry->next = entry; 80266c: e0c00317 ldw r3,12(fp) 802670: e0800317 ldw r2,12(fp) 802674: 18800015 stw r2,0(r3) */ static ALT_INLINE void ALT_ALWAYS_INLINE alt_irq_enable_all (alt_irq_context context) { 802678: e0800117 ldw r2,4(fp) 80267c: e0800315 stw r2,12(fp) NIOS2_WRITE_STATUS (context); 802680: e0800317 ldw r2,12(fp) 802684: 1001703a wrctl status,r2 alt_irq_context irq_context; irq_context = alt_irq_disable_all(); alt_llist_remove (&alarm->llist); alt_irq_enable_all (irq_context); } 802688: df000417 ldw fp,16(sp) 80268c: dec00504 addi sp,sp,20 802690: f800283a ret 00802694 <alt_tick>: /* * alt_tick() is periodically called by the system clock driver in order to * process the registered list of alarms. Each alarm is registed with a * callback interval, and a callback function, "callback". * * The return value of the callback function indicates how many ticks are to * elapse until the next callback. A return value of zero indicates that the * alarm should be deactivated. * * alt_tick() is expected to run at interrupt level. */ void alt_tick (void) { 802694: defffb04 addi sp,sp,-20 802698: dfc00415 stw ra,16(sp) 80269c: df000315 stw fp,12(sp) 8026a0: d839883a mov fp,sp alt_alarm* next; alt_alarm* alarm = (alt_alarm*) alt_alarm_list.next; 8026a4: d0a01017 ldw r2,-32704(gp) 8026a8: e0800115 stw r2,4(fp) alt_u32 next_callback; /* update the tick counter */ _alt_nticks++; 8026ac: d0a00f17 ldw r2,-32708(gp) 8026b0: 10800044 addi r2,r2,1 8026b4: d0a00f15 stw r2,-32708(gp) /* process the registered callbacks */ while (alarm != (alt_alarm*) &alt_alarm_list) 8026b8: e0c00117 ldw r3,4(fp) 8026bc: d0a01004 addi r2,gp,-32704 8026c0: 18803026 beq r3,r2,802784 <alt_tick+0xf0> { next = (alt_alarm*) alarm->llist.next; 8026c4: e0800117 ldw r2,4(fp) 8026c8: 10800017 ldw r2,0(r2) 8026cc: e0800015 stw r2,0(fp) /* * Upon the tick-counter rolling over it is safe to clear the * roll-over flag; once the flag is cleared this (or subsequnt) * tick events are enabled to generate an alarm event. */ if ((alarm->rollover) && (_alt_nticks == 0)) 8026d0: e0800117 ldw r2,4(fp) 8026d4: 10800403 ldbu r2,16(r2) 8026d8: 1005003a cmpeq r2,r2,zero 8026dc: 1000051e bne r2,zero,8026f4 <alt_tick+0x60> 8026e0: d0a00f17 ldw r2,-32708(gp) 8026e4: 1004c03a cmpne r2,r2,zero 8026e8: 1000021e bne r2,zero,8026f4 <alt_tick+0x60> { alarm->rollover = 0; 8026ec: e0800117 ldw r2,4(fp) 8026f0: 10000405 stb zero,16(r2) } /* if the alarm period has expired, make the callback */ if ((alarm->time <= _alt_nticks) && (alarm->rollover == 0)) 8026f4: e0800117 ldw r2,4(fp) 8026f8: 10c00217 ldw r3,8(r2) 8026fc: d0a00f17 ldw r2,-32708(gp) 802700: 10c01d36 bltu r2,r3,802778 <alt_tick+0xe4> 802704: e0800117 ldw r2,4(fp) 802708: 10800403 ldbu r2,16(r2) 80270c: 1004c03a cmpne r2,r2,zero 802710: 1000191e bne r2,zero,802778 <alt_tick+0xe4> { next_callback = alarm->callback (alarm->context); 802714: e0800117 ldw r2,4(fp) 802718: e0c00117 ldw r3,4(fp) 80271c: 10800317 ldw r2,12(r2) 802720: 19000517 ldw r4,20(r3) 802724: 103ee83a callr r2 802728: e0800215 stw r2,8(fp) /* deactivate the alarm if the return value is zero */ if (next_callback == 0) 80272c: e0800217 ldw r2,8(fp) 802730: 1004c03a cmpne r2,r2,zero 802734: 1000031e bne r2,zero,802744 <alt_tick+0xb0> { alt_alarm_stop (alarm); 802738: e1000117 ldw r4,4(fp) 80273c: 08026040 call 802604 <alt_alarm_stop> 802740: 00000d06 br 802778 <alt_tick+0xe4> } else { alarm->time += next_callback; 802744: e1000117 ldw r4,4(fp) 802748: e0800117 ldw r2,4(fp) 80274c: 10c00217 ldw r3,8(r2) 802750: e0800217 ldw r2,8(fp) 802754: 1885883a add r2,r3,r2 802758: 20800215 stw r2,8(r4) /* * If the desired alarm time causes a roll-over, set the rollover * flag. This will prevent the subsequent tick event from causing * an alarm too early. */ if(alarm->time < _alt_nticks) 80275c: e0800117 ldw r2,4(fp) 802760: 10c00217 ldw r3,8(r2) 802764: d0a00f17 ldw r2,-32708(gp) 802768: 1880032e bgeu r3,r2,802778 <alt_tick+0xe4> { alarm->rollover = 1; 80276c: e0c00117 ldw r3,4(fp) 802770: 00800044 movi r2,1 802774: 18800405 stb r2,16(r3) } } } alarm = next; 802778: e0800017 ldw r2,0(fp) 80277c: e0800115 stw r2,4(fp) 802780: 003fcd06 br 8026b8 <alt_tick+0x24> } /* * Update the operating system specific timer facilities. */ ALT_OS_TIME_TICK(); } 802784: dfc00417 ldw ra,16(sp) 802788: df000317 ldw fp,12(sp) 80278c: dec00504 addi sp,sp,20 802790: f800283a ret 00802794 <usleep>: * ALT_USLEEP is mapped onto the usleep() system call in alt_syscall.h */ unsigned int ALT_USLEEP (unsigned int us) { 802794: defffd04 addi sp,sp,-12 802798: dfc00215 stw ra,8(sp) 80279c: df000115 stw fp,4(sp) 8027a0: d839883a mov fp,sp 8027a4: e1000015 stw r4,0(fp) return alt_busy_sleep(us); 8027a8: e1000017 ldw r4,0(fp) 8027ac: 08027c00 call 8027c0 <alt_busy_sleep> } 8027b0: dfc00217 ldw ra,8(sp) 8027b4: df000117 ldw fp,4(sp) 8027b8: dec00304 addi sp,sp,12 8027bc: f800283a ret 008027c0 <alt_busy_sleep>: #include "priv/alt_busy_sleep.h" unsigned int alt_busy_sleep (unsigned int us) { 8027c0: defffa04 addi sp,sp,-24 8027c4: dfc00515 stw ra,20(sp) 8027c8: df000415 stw fp,16(sp) 8027cc: d839883a mov fp,sp 8027d0: e1000015 stw r4,0(fp) /* * Only delay if ALT_SIM_OPTIMIZE is not defined; i.e., if software * is built targetting ModelSim RTL simulation, the delay will be * skipped to speed up simulation. */ #ifndef ALT_SIM_OPTIMIZE int i; int big_loops; alt_u32 cycles_per_loop; if (!strcmp(NIOS2_CPU_IMPLEMENTATION,"tiny")) { cycles_per_loop = 9; } else { cycles_per_loop = 3; 8027d4: 008000c4 movi r2,3 8027d8: e0800315 stw r2,12(fp) } big_loops = us / (INT_MAX/ 8027dc: e0c00317 ldw r3,12(fp) 8027e0: 008003f4 movhi r2,15 8027e4: 10909004 addi r2,r2,16960 8027e8: 188b383a mul r5,r3,r2 8027ec: 0100bef4 movhi r4,763 8027f0: 213c2004 addi r4,r4,-3968 8027f4: 0803b5c0 call 803b5c <__udivsi3> 8027f8: 100b883a mov r5,r2 8027fc: 01200034 movhi r4,32768 802800: 213fffc4 addi r4,r4,-1 802804: 0803b5c0 call 803b5c <__udivsi3> 802808: 100b883a mov r5,r2 80280c: e1000017 ldw r4,0(fp) 802810: 0803b5c0 call 803b5c <__udivsi3> 802814: e0800215 stw r2,8(fp) (ALT_CPU_FREQ/(cycles_per_loop * 1000000))); if (big_loops) 802818: e0800217 ldw r2,8(fp) 80281c: 1005003a cmpeq r2,r2,zero 802820: 1000281e bne r2,zero,8028c4 <alt_busy_sleep+0x104> { for(i=0;i<big_loops;i++) 802824: e0000115 stw zero,4(fp) 802828: e0c00117 ldw r3,4(fp) 80282c: e0800217 ldw r2,8(fp) 802830: 1880170e bge r3,r2,802890 <alt_busy_sleep+0xd0> { /* * Do NOT Try to single step the asm statement below * (single step will never return) * Step out of this function or set a breakpoint after the asm statements */ __asm__ volatile ( 802834: 00a00034 movhi r2,32768 802838: 10bfffc4 addi r2,r2,-1 80283c: 10bfffc4 addi r2,r2,-1 802840: 103ffe1e bne r2,zero,80283c <alt_busy_sleep+0x7c> "\n0:" "\n\taddi %0,%0, -1" "\n\tbne %0,zero,0b" "\n1:" "\n\t.pushsection .debug_alt_sim_info" "\n\t.int 4, 0, 0b, 1b" "\n\t.popsection" :: "r" (INT_MAX)); us -= (INT_MAX/(ALT_CPU_FREQ/ 802844: e0c00317 ldw r3,12(fp) 802848: 008003f4 movhi r2,15 80284c: 10909004 addi r2,r2,16960 802850: 188b383a mul r5,r3,r2 802854: 0100bef4 movhi r4,763 802858: 213c2004 addi r4,r4,-3968 80285c: 0803b5c0 call 803b5c <__udivsi3> 802860: 100b883a mov r5,r2 802864: 01200034 movhi r4,32768 802868: 213fffc4 addi r4,r4,-1 80286c: 0803b5c0 call 803b5c <__udivsi3> 802870: 1007883a mov r3,r2 802874: e0800017 ldw r2,0(fp) 802878: 10c5c83a sub r2,r2,r3 80287c: e0800015 stw r2,0(fp) 802880: e0800117 ldw r2,4(fp) 802884: 10800044 addi r2,r2,1 802888: e0800115 stw r2,4(fp) 80288c: 003fe606 br 802828 <alt_busy_sleep+0x68> (cycles_per_loop * 1000000))); } /* * Do NOT Try to single step the asm statement below * (single step will never return) * Step out of this function or set a breakpoint after the asm statements */ __asm__ volatile ( 802890: e0c00317 ldw r3,12(fp) 802894: 008003f4 movhi r2,15 802898: 10909004 addi r2,r2,16960 80289c: 188b383a mul r5,r3,r2 8028a0: 0100bef4 movhi r4,763 8028a4: 213c2004 addi r4,r4,-3968 8028a8: 0803b5c0 call 803b5c <__udivsi3> 8028ac: 1007883a mov r3,r2 8028b0: e0800017 ldw r2,0(fp) 8028b4: 1885383a mul r2,r3,r2 8028b8: 10bfffc4 addi r2,r2,-1 8028bc: 103ffe1e bne r2,zero,8028b8 <alt_busy_sleep+0xf8> 8028c0: 00000c06 br 8028f4 <alt_busy_sleep+0x134> "\n0:" "\n\taddi %0,%0, -1" "\n\tbne %0,zero,0b" "\n1:" "\n\t.pushsection .debug_alt_sim_info" "\n\t.int 4, 0, 0b, 1b" "\n\t.popsection" :: "r" (us*(ALT_CPU_FREQ/(cycles_per_loop * 1000000)))); } else { /* * Do NOT Try to single step the asm statement below * (single step will never return) * Step out of this function or set a breakpoint after the asm statements */ __asm__ volatile ( 8028c4: e0c00317 ldw r3,12(fp) 8028c8: 008003f4 movhi r2,15 8028cc: 10909004 addi r2,r2,16960 8028d0: 188b383a mul r5,r3,r2 8028d4: 0100bef4 movhi r4,763 8028d8: 213c2004 addi r4,r4,-3968 8028dc: 0803b5c0 call 803b5c <__udivsi3> 8028e0: 1007883a mov r3,r2 8028e4: e0800017 ldw r2,0(fp) 8028e8: 1885383a mul r2,r3,r2 8028ec: 10bfffc4 addi r2,r2,-1 8028f0: 00bffe16 blt zero,r2,8028ec <alt_busy_sleep+0x12c> "\n0:" "\n\taddi %0,%0, -1" "\n\tbgt %0,zero,0b" "\n1:" "\n\t.pushsection .debug_alt_sim_info" "\n\t.int 4, 0, 0b, 1b" "\n\t.popsection" :: "r" (us*(ALT_CPU_FREQ/(cycles_per_loop * 1000000)))); } #endif /* #ifndef ALT_SIM_OPTIMIZE */ return 0; 8028f4: 0005883a mov r2,zero } 8028f8: dfc00517 ldw ra,20(sp) 8028fc: df000417 ldw fp,16(sp) 802900: dec00604 addi sp,sp,24 802904: f800283a ret 00802908 <alt_find_dev>: * be found. */ alt_dev* alt_find_dev(const char* name, alt_llist* llist) { 802908: defff904 addi sp,sp,-28 80290c: dfc00615 stw ra,24(sp) 802910: df000515 stw fp,20(sp) 802914: d839883a mov fp,sp 802918: e1000015 stw r4,0(fp) 80291c: e1400115 stw r5,4(fp) alt_dev* next = (alt_dev*) llist->next; 802920: e0800117 ldw r2,4(fp) 802924: 10800017 ldw r2,0(r2) 802928: e0800215 stw r2,8(fp) alt_32 len; len = strlen(name) + 1; 80292c: e1000017 ldw r4,0(fp) 802930: 08036280 call 803628 <strlen> 802934: 10800044 addi r2,r2,1 802938: e0800315 stw r2,12(fp) /* * Check each list entry in turn, until a match is found, or we reach the * end of the list (i.e. next winds up pointing back to the list head). */ while (next != (alt_dev*) llist) 80293c: e0c00217 ldw r3,8(fp) 802940: e0800117 ldw r2,4(fp) 802944: 18800e26 beq r3,r2,802980 <alt_find_dev+0x78> { /* * memcmp() is used here rather than strcmp() in order to reduce the size * of the executable. */ if (!memcmp (next->name, name, len)) 802948: e0800217 ldw r2,8(fp) 80294c: 11000217 ldw r4,8(r2) 802950: e1400017 ldw r5,0(fp) 802954: e1800317 ldw r6,12(fp) 802958: 08034140 call 803414 <memcmp> 80295c: 1004c03a cmpne r2,r2,zero 802960: 1000031e bne r2,zero,802970 <alt_find_dev+0x68> { /* match found */ return next; 802964: e0800217 ldw r2,8(fp) 802968: e0800415 stw r2,16(fp) 80296c: 00000506 br 802984 <alt_find_dev+0x7c> } next = (alt_dev*) next->llist.next; 802970: e0800217 ldw r2,8(fp) 802974: 10800017 ldw r2,0(r2) 802978: e0800215 stw r2,8(fp) 80297c: 003fef06 br 80293c <alt_find_dev+0x34> } /* No match found */ return NULL; 802980: e0000415 stw zero,16(fp) } 802984: e0800417 ldw r2,16(fp) 802988: dfc00617 ldw ra,24(sp) 80298c: df000517 ldw fp,20(sp) 802990: dec00704 addi sp,sp,28 802994: f800283a ret 00802998 <alt_find_file>: * "/myfilesystem/junk.txt" would match: "/myfilesystem", but not: "/myfile". */ alt_dev* alt_find_file (const char* name) { 802998: defffa04 addi sp,sp,-24 80299c: dfc00515 stw ra,20(sp) 8029a0: df000415 stw fp,16(sp) 8029a4: d839883a mov fp,sp 8029a8: e1000015 stw r4,0(fp) alt_dev* next = (alt_dev*) alt_fs_list.next; 8029ac: d0a00617 ldw r2,-32744(gp) 8029b0: e0800115 stw r2,4(fp) alt_32 len; /* * Check each list entry in turn, until a match is found, or we reach the * end of the list (i.e. next winds up pointing back to the list head). */ while (next != (alt_dev*) &alt_fs_list) 8029b4: e0c00117 ldw r3,4(fp) 8029b8: d0a00604 addi r2,gp,-32744 8029bc: 18802926 beq r3,r2,802a64 <alt_find_file+0xcc> { len = strlen(next->name); 8029c0: e0800117 ldw r2,4(fp) 8029c4: 11000217 ldw r4,8(r2) 8029c8: 08036280 call 803628 <strlen> 8029cc: e0800215 stw r2,8(fp) if (next->name[len-1] == '/') 8029d0: e0800117 ldw r2,4(fp) 8029d4: 10c00217 ldw r3,8(r2) 8029d8: e0800217 ldw r2,8(fp) 8029dc: 1885883a add r2,r3,r2 8029e0: 10bfffc4 addi r2,r2,-1 8029e4: 10800007 ldb r2,0(r2) 8029e8: 10800bd8 cmpnei r2,r2,47 8029ec: 1000031e bne r2,zero,8029fc <alt_find_file+0x64> { len -= 1; 8029f0: e0800217 ldw r2,8(fp) 8029f4: 10bfffc4 addi r2,r2,-1 8029f8: e0800215 stw r2,8(fp) } if (((name[len] == '/') || (name[len] == '\0')) && 8029fc: e0c00017 ldw r3,0(fp) 802a00: e0800217 ldw r2,8(fp) 802a04: 1885883a add r2,r3,r2 802a08: 10800007 ldb r2,0(r2) 802a0c: 10800be0 cmpeqi r2,r2,47 802a10: 1000061e bne r2,zero,802a2c <alt_find_file+0x94> 802a14: e0c00017 ldw r3,0(fp) 802a18: e0800217 ldw r2,8(fp) 802a1c: 1885883a add r2,r3,r2 802a20: 10800007 ldb r2,0(r2) 802a24: 1004c03a cmpne r2,r2,zero 802a28: 10000a1e bne r2,zero,802a54 <alt_find_file+0xbc> 802a2c: e0800117 ldw r2,4(fp) 802a30: 11000217 ldw r4,8(r2) 802a34: e1400017 ldw r5,0(fp) 802a38: e1800217 ldw r6,8(fp) 802a3c: 08034140 call 803414 <memcmp> 802a40: 1004c03a cmpne r2,r2,zero 802a44: 1000031e bne r2,zero,802a54 <alt_find_file+0xbc> !memcmp (next->name, name, len)) { /* match found */ return next; 802a48: e0800117 ldw r2,4(fp) 802a4c: e0800315 stw r2,12(fp) 802a50: 00000506 br 802a68 <alt_find_file+0xd0> } next = (alt_dev*) next->llist.next; 802a54: e0800117 ldw r2,4(fp) 802a58: 10800017 ldw r2,0(r2) 802a5c: e0800115 stw r2,4(fp) 802a60: 003fd406 br 8029b4 <alt_find_file+0x1c> } /* No match found */ return NULL; 802a64: e0000315 stw zero,12(fp) } 802a68: e0800317 ldw r2,12(fp) 802a6c: dfc00517 ldw ra,20(sp) 802a70: df000417 ldw fp,16(sp) 802a74: dec00604 addi sp,sp,24 802a78: f800283a ret 00802a7c <alt_get_fd>: * negative value indicates failure. */ int alt_get_fd (alt_dev* dev) { 802a7c: defffa04 addi sp,sp,-24 802a80: df000515 stw fp,20(sp) 802a84: d839883a mov fp,sp 802a88: e1000015 stw r4,0(fp) alt_32 i; int rc = -EMFILE; 802a8c: 00bffa04 movi r2,-24 802a90: e0800215 stw r2,8(fp) */ static ALT_INLINE int ALT_ALWAYS_INLINE alt_no_error (void) { return 0; 802a94: e0000315 stw zero,12(fp) /* * Take the alt_fd_list_lock semaphore in order to avoid races when * accessing the file descriptor pool. */ ALT_SEM_PEND(alt_fd_list_lock, 0); /* * Search through the list of file descriptors, and allocate the first * free descriptor that's found. * * If a free descriptor is found, then the value of "alt_max_fd" is * updated accordingly. "alt_max_fd" is a 'highwater mark' which * indicates the highest file descriptor ever allocated. This is used to * improve efficency when searching the file descriptor list, and * therefore reduce contention on the alt_fd_list_lock semaphore. */ for (i = 0; i < ALT_MAX_FD; i++) 802a98: e0000115 stw zero,4(fp) 802a9c: e0800117 ldw r2,4(fp) 802aa0: 10800808 cmpgei r2,r2,32 802aa4: 10001b1e bne r2,zero,802b14 <alt_get_fd+0x98> { if (!alt_fd_list[i].dev) 802aa8: 00c02034 movhi r3,128 802aac: 18d40704 addi r3,r3,20508 802ab0: e0800117 ldw r2,4(fp) 802ab4: 10800324 muli r2,r2,12 802ab8: 10c5883a add r2,r2,r3 802abc: 10800017 ldw r2,0(r2) 802ac0: 1004c03a cmpne r2,r2,zero 802ac4: 10000f1e bne r2,zero,802b04 <alt_get_fd+0x88> { alt_fd_list[i].dev = dev; 802ac8: 00c02034 movhi r3,128 802acc: 18d40704 addi r3,r3,20508 802ad0: e0800117 ldw r2,4(fp) 802ad4: 10800324 muli r2,r2,12 802ad8: 10c7883a add r3,r2,r3 802adc: e0800017 ldw r2,0(fp) 802ae0: 18800015 stw r2,0(r3) if (i > alt_max_fd) 802ae4: e0c00117 ldw r3,4(fp) 802ae8: d0a00a17 ldw r2,-32728(gp) 802aec: 10c0020e bge r2,r3,802af8 <alt_get_fd+0x7c> { alt_max_fd = i; 802af0: e0800117 ldw r2,4(fp) 802af4: d0a00a15 stw r2,-32728(gp) } rc = i; 802af8: e0800117 ldw r2,4(fp) 802afc: e0800215 stw r2,8(fp) goto alt_get_fd_exit; 802b00: 00000406 br 802b14 <alt_get_fd+0x98> 802b04: e0800117 ldw r2,4(fp) 802b08: 10800044 addi r2,r2,1 802b0c: e0800115 stw r2,4(fp) 802b10: 003fe206 br 802a9c <alt_get_fd+0x20> */ static ALT_INLINE int ALT_ALWAYS_INLINE alt_no_error (void) { return 0; 802b14: e0000415 stw zero,16(fp) } } alt_get_fd_exit: /* * Release the alt_fd_list_lock semaphore now that we are done with the * file descriptor pool. */ ALT_SEM_POST(alt_fd_list_lock); return rc; 802b18: e0800217 ldw r2,8(fp) } 802b1c: df000517 ldw fp,20(sp) 802b20: dec00604 addi sp,sp,24 802b24: f800283a ret 00802b28 <alt_icache_flush>: * region of length "len" bytes, starting at address "start". */ void alt_icache_flush (void* start, alt_u32 len) { 802b28: defffb04 addi sp,sp,-20 802b2c: df000415 stw fp,16(sp) 802b30: d839883a mov fp,sp 802b34: e1000015 stw r4,0(fp) 802b38: e1400115 stw r5,4(fp) #if NIOS2_ICACHE_SIZE > 0 char* i; char* end; /* * This is the most we would ever need to flush. */ if (len > NIOS2_ICACHE_SIZE) 802b3c: e0800117 ldw r2,4(fp) 802b40: 10840070 cmpltui r2,r2,4097 802b44: 1000021e bne r2,zero,802b50 <alt_icache_flush+0x28> { len = NIOS2_ICACHE_SIZE; 802b48: 00840004 movi r2,4096 802b4c: e0800115 stw r2,4(fp) } end = ((char*) start) + len; 802b50: e0c00017 ldw r3,0(fp) 802b54: e0800117 ldw r2,4(fp) 802b58: 1885883a add r2,r3,r2 802b5c: e0800315 stw r2,12(fp) for (i = start; i < end; i+= NIOS2_ICACHE_LINE_SIZE) 802b60: e0800017 ldw r2,0(fp) 802b64: e0800215 stw r2,8(fp) 802b68: e0c00217 ldw r3,8(fp) 802b6c: e0800317 ldw r2,12(fp) 802b70: 1880062e bgeu r3,r2,802b8c <alt_icache_flush+0x64> { __asm__ volatile ("flushi %0" :: "r" (i)); 802b74: e0800217 ldw r2,8(fp) 802b78: 1000603a flushi r2 802b7c: e0800217 ldw r2,8(fp) 802b80: 10800804 addi r2,r2,32 802b84: e0800215 stw r2,8(fp) 802b88: 003ff706 br 802b68 <alt_icache_flush+0x40> } /* * For an unaligned flush request, we've got one more line left. * Note that this is dependent on NIOS2_ICACHE_LINE_SIZE to be a * multiple of 2 (which it always is). */ if (((alt_u32) start) & (NIOS2_ICACHE_LINE_SIZE - 1)) 802b8c: e0800017 ldw r2,0(fp) 802b90: 108007cc andi r2,r2,31 802b94: 1005003a cmpeq r2,r2,zero 802b98: 1000021e bne r2,zero,802ba4 <alt_icache_flush+0x7c> { __asm__ volatile ("flushi %0" :: "r" (i)); 802b9c: e0800217 ldw r2,8(fp) 802ba0: 1000603a flushi r2 } /* * Having flushed the cache, flush any stale instructions in the * pipeline */ __asm__ volatile ("flushp"); 802ba4: 0000203a flushp #endif /* NIOS2_ICACHE_SIZE > 0 */ } 802ba8: df000417 ldw fp,16(sp) 802bac: dec00504 addi sp,sp,20 802bb0: f800283a ret 00802bb4 <atexit>: 802bb4: d0a01317 ldw r2,-32692(gp) 802bb8: defffe04 addi sp,sp,-8 802bbc: dc000015 stw r16,0(sp) 802bc0: dfc00115 stw ra,4(sp) 802bc4: 11405217 ldw r5,328(r2) 802bc8: 2021883a mov r16,r4 802bcc: 01004304 movi r4,268 802bd0: 28001b26 beq r5,zero,802c40 <atexit+0x8c> 802bd4: 28c00117 ldw r3,4(r5) 802bd8: 008007c4 movi r2,31 802bdc: 10c00d16 blt r2,r3,802c14 <atexit+0x60> 802be0: 28800104 addi r2,r5,4 802be4: 10c00017 ldw r3,0(r2) 802be8: 000d883a mov r6,zero 802bec: 180890ba slli r4,r3,2 802bf0: 18c00044 addi r3,r3,1 802bf4: 10c00015 stw r3,0(r2) 802bf8: 2149883a add r4,r4,r5 802bfc: 24000215 stw r16,8(r4) 802c00: 3005883a mov r2,r6 802c04: dfc00117 ldw ra,4(sp) 802c08: dc000017 ldw r16,0(sp) 802c0c: dec00204 addi sp,sp,8 802c10: f800283a ret 802c14: 0802d340 call 802d34 <malloc> 802c18: 100b883a mov r5,r2 802c1c: 01bfffc4 movi r6,-1 802c20: 103ff726 beq r2,zero,802c00 <atexit+0x4c> 802c24: d0e01317 ldw r3,-32692(gp) 802c28: 10004215 stw zero,264(r2) 802c2c: 10000115 stw zero,4(r2) 802c30: 18805217 ldw r2,328(r3) 802c34: 28800015 stw r2,0(r5) 802c38: 19405215 stw r5,328(r3) 802c3c: 003fe806 br 802be0 <atexit+0x2c> 802c40: 01402034 movhi r5,128 802c44: 2956ae04 addi r5,r5,23224 802c48: 11405215 stw r5,328(r2) 802c4c: 003fe106 br 802bd4 <atexit+0x20> 00802c50 <exit>: 802c50: d0a01317 ldw r2,-32692(gp) 802c54: defff804 addi sp,sp,-32 802c58: dd800015 stw r22,0(sp) 802c5c: dfc00715 stw ra,28(sp) 802c60: dc000615 stw r16,24(sp) 802c64: dc400515 stw r17,20(sp) 802c68: dc800415 stw r18,16(sp) 802c6c: dcc00315 stw r19,12(sp) 802c70: dd000215 stw r20,8(sp) 802c74: dd400115 stw r21,4(sp) 802c78: 15005217 ldw r20,328(r2) 802c7c: 202d883a mov r22,r4 802c80: a0002526 beq r20,zero,802d18 <exit+0xc8> 802c84: a0800117 ldw r2,4(r20) 802c88: a5402204 addi r21,r20,136 802c8c: 0027883a mov r19,zero 802c90: 143fffc4 addi r16,r2,-1 802c94: 8006803a cmplt r3,r16,zero 802c98: 1800021e bne r3,zero,802ca4 <exit+0x54> 802c9c: 00800044 movi r2,1 802ca0: 1426983a sll r19,r2,r16 802ca4: 1800191e bne r3,zero,802d0c <exit+0xbc> 802ca8: 800490ba slli r2,r16,2 802cac: 1025883a mov r18,r2 802cb0: 1505883a add r2,r2,r20 802cb4: 14400204 addi r17,r2,8 802cb8: 00000806 br 802cdc <exit+0x8c> 802cbc: 88800017 ldw r2,0(r17) 802cc0: 29400017 ldw r5,0(r5) 802cc4: 843fffc4 addi r16,r16,-1 802cc8: 94bfff04 addi r18,r18,-4 802ccc: 103ee83a callr r2 802cd0: 8c7fff04 addi r17,r17,-4 802cd4: 9827d07a srai r19,r19,1 802cd8: 80000c16 blt r16,zero,802d0c <exit+0xbc> 802cdc: a8802017 ldw r2,128(r21) 802ce0: 954b883a add r5,r18,r21 802ce4: b009883a mov r4,r22 802ce8: 14c4703a and r2,r2,r19 802cec: 103ff31e bne r2,zero,802cbc <exit+0x6c> 802cf0: 88800017 ldw r2,0(r17) 802cf4: 843fffc4 addi r16,r16,-1 802cf8: 94bfff04 addi r18,r18,-4 802cfc: 103ee83a callr r2 802d00: 8c7fff04 addi r17,r17,-4 802d04: 9827d07a srai r19,r19,1 802d08: 803ff40e bge r16,zero,802cdc <exit+0x8c> 802d0c: a5000017 ldw r20,0(r20) 802d10: a03fdc1e bne r20,zero,802c84 <exit+0x34> 802d14: d0a01317 ldw r2,-32692(gp) 802d18: 10c00f17 ldw r3,60(r2) 802d1c: 1800021e bne r3,zero,802d28 <exit+0xd8> 802d20: b009883a mov r4,r22 802d24: 0803bac0 call 803bac <_exit> 802d28: 1009883a mov r4,r2 802d2c: 183ee83a callr r3 802d30: 003ffb06 br 802d20 <exit+0xd0> 00802d34 <malloc>: 802d34: 200b883a mov r5,r4 802d38: d1201317 ldw r4,-32692(gp) 802d3c: 02002034 movhi r8,128 802d40: 420b5704 addi r8,r8,11612 802d44: 4000683a jmp r8 00802d48 <free>: 802d48: 200b883a mov r5,r4 802d4c: d1201317 ldw r4,-32692(gp) 802d50: 02002034 movhi r8,128 802d54: 420dea04 addi r8,r8,14248 802d58: 4000683a jmp r8 00802d5c <_malloc_r>: 802d5c: defff504 addi sp,sp,-44 802d60: 28c002c4 addi r3,r5,11 802d64: 00800584 movi r2,22 802d68: dc400715 stw r17,28(sp) 802d6c: dc800615 stw r18,24(sp) 802d70: dfc00a15 stw ra,40(sp) 802d74: df000915 stw fp,36(sp) 802d78: dc000815 stw r16,32(sp) 802d7c: dcc00515 stw r19,20(sp) 802d80: dd000415 stw r20,16(sp) 802d84: dd400315 stw r21,12(sp) 802d88: dd800215 stw r22,8(sp) 802d8c: ddc00115 stw r23,4(sp) 802d90: 2025883a mov r18,r4 802d94: 04400404 movi r17,16 802d98: 10c0032e bgeu r2,r3,802da8 <_malloc_r+0x4c> 802d9c: 00bffe04 movi r2,-8 802da0: 18a2703a and r17,r3,r2 802da4: 88000116 blt r17,zero,802dac <_malloc_r+0x50> 802da8: 89400d2e bgeu r17,r5,802de0 <_malloc_r+0x84> 802dac: 0005883a mov r2,zero 802db0: dfc00a17 ldw ra,40(sp) 802db4: df000917 ldw fp,36(sp) 802db8: dc000817 ldw r16,32(sp) 802dbc: dc400717 ldw r17,28(sp) 802dc0: dc800617 ldw r18,24(sp) 802dc4: dcc00517 ldw r19,20(sp) 802dc8: dd000417 ldw r20,16(sp) 802dcc: dd400317 ldw r21,12(sp) 802dd0: dd800217 ldw r22,8(sp) 802dd4: ddc00117 ldw r23,4(sp) 802dd8: dec00b04 addi sp,sp,44 802ddc: f800283a ret 802de0: 9009883a mov r4,r18 802de4: 0803bcc0 call 803bcc <__malloc_lock> 802de8: 00807dc4 movi r2,503 802dec: 14401536 bltu r2,r17,802e44 <_malloc_r+0xe8> 802df0: 03402034 movhi r13,128 802df4: 6b555004 addi r13,r13,21824 802df8: 8b4d883a add r6,r17,r13 802dfc: 34000317 ldw r16,12(r6) 802e00: 8812d0fa srli r9,r17,3 802e04: 81803e26 beq r16,r6,802f00 <_malloc_r+0x1a4> 802e08: 80c00117 ldw r3,4(r16) 802e0c: 00bfff04 movi r2,-4 802e10: 82000317 ldw r8,12(r16) 802e14: 1886703a and r3,r3,r2 802e18: 80cb883a add r5,r16,r3 802e1c: 28800117 ldw r2,4(r5) 802e20: 81c00217 ldw r7,8(r16) 802e24: 9009883a mov r4,r18 802e28: 10800054 ori r2,r2,1 802e2c: 41c00215 stw r7,8(r8) 802e30: 28800115 stw r2,4(r5) 802e34: 3a000315 stw r8,12(r7) 802e38: 0803be80 call 803be8 <__malloc_unlock> 802e3c: 80800204 addi r2,r16,8 802e40: 003fdb06 br 802db0 <_malloc_r+0x54> 802e44: 8806d27a srli r3,r17,9 802e48: 8812d0fa srli r9,r17,3 802e4c: 18000926 beq r3,zero,802e74 <_malloc_r+0x118> 802e50: 00800104 movi r2,4 802e54: 10c02f2e bgeu r2,r3,802f14 <_malloc_r+0x1b8> 802e58: 00800504 movi r2,20 802e5c: 1a4016c4 addi r9,r3,91 802e60: 10c0042e bgeu r2,r3,802e74 <_malloc_r+0x118> 802e64: 00801504 movi r2,84 802e68: 10c11536 bltu r2,r3,8032c0 <_malloc_r+0x564> 802e6c: 8804d33a srli r2,r17,12 802e70: 12401b84 addi r9,r2,110 802e74: 480490fa slli r2,r9,3 802e78: 03402034 movhi r13,128 802e7c: 6b555004 addi r13,r13,21824 802e80: 134b883a add r5,r2,r13 802e84: 2c000317 ldw r16,12(r5) 802e88: 81400926 beq r16,r5,802eb0 <_malloc_r+0x154> 802e8c: 01ffff04 movi r7,-4 802e90: 018003c4 movi r6,15 802e94: 80800117 ldw r2,4(r16) 802e98: 11c6703a and r3,r2,r7 802e9c: 1c49c83a sub r4,r3,r17 802ea0: 3100aa16 blt r6,r4,80314c <_malloc_r+0x3f0> 802ea4: 2000690e bge r4,zero,80304c <_malloc_r+0x2f0> 802ea8: 84000317 ldw r16,12(r16) 802eac: 817ff91e bne r16,r5,802e94 <_malloc_r+0x138> 802eb0: 4a400044 addi r9,r9,1 802eb4: 03002034 movhi r12,128 802eb8: 63155204 addi r12,r12,21832 802ebc: 64000217 ldw r16,8(r12) 802ec0: 83002826 beq r16,r12,802f64 <_malloc_r+0x208> 802ec4: 80800117 ldw r2,4(r16) 802ec8: 00ffff04 movi r3,-4 802ecc: 10c6703a and r3,r2,r3 802ed0: 1c49c83a sub r4,r3,r17 802ed4: 008003c4 movi r2,15 802ed8: 11006616 blt r2,r4,803074 <_malloc_r+0x318> 802edc: 63000315 stw r12,12(r12) 802ee0: 63000215 stw r12,8(r12) 802ee4: 20000e16 blt r4,zero,802f20 <_malloc_r+0x1c4> 802ee8: 80c7883a add r3,r16,r3 802eec: 18800117 ldw r2,4(r3) 802ef0: 9009883a mov r4,r18 802ef4: 10800054 ori r2,r2,1 802ef8: 18800115 stw r2,4(r3) 802efc: 003fce06 br 802e38 <_malloc_r+0xdc> 802f00: 81800204 addi r6,r16,8 802f04: 34000317 ldw r16,12(r6) 802f08: 81bfbf1e bne r16,r6,802e08 <_malloc_r+0xac> 802f0c: 4a400084 addi r9,r9,2 802f10: 003fe806 br 802eb4 <_malloc_r+0x158> 802f14: 8804d1ba srli r2,r17,6 802f18: 12400e04 addi r9,r2,56 802f1c: 003fd506 br 802e74 <_malloc_r+0x118> 802f20: 00807fc4 movi r2,511 802f24: 10c09436 bltu r2,r3,803178 <_malloc_r+0x41c> 802f28: 1808d0fa srli r4,r3,3 802f2c: 61bffe04 addi r6,r12,-8 802f30: 00800044 movi r2,1 802f34: 200a90fa slli r5,r4,3 802f38: 2007d0ba srai r3,r4,2 802f3c: 31000117 ldw r4,4(r6) 802f40: 2991883a add r8,r5,r6 802f44: 41c00217 ldw r7,8(r8) 802f48: 10c4983a sll r2,r2,r3 802f4c: 82000315 stw r8,12(r16) 802f50: 81c00215 stw r7,8(r16) 802f54: 2088b03a or r4,r4,r2 802f58: 3c000315 stw r16,12(r7) 802f5c: 31000115 stw r4,4(r6) 802f60: 44000215 stw r16,8(r8) 802f64: 4807883a mov r3,r9 802f68: 4800a616 blt r9,zero,803204 <_malloc_r+0x4a8> 802f6c: 1807d0ba srai r3,r3,2 802f70: 03402034 movhi r13,128 802f74: 6b555004 addi r13,r13,21824 802f78: 00800044 movi r2,1 802f7c: 10ce983a sll r7,r2,r3 802f80: 69000117 ldw r4,4(r13) 802f84: 21c04836 bltu r4,r7,8030a8 <_malloc_r+0x34c> 802f88: 21c4703a and r2,r4,r7 802f8c: 10000a1e bne r2,zero,802fb8 <_malloc_r+0x25c> 802f90: 39cf883a add r7,r7,r7 802f94: 00bfff04 movi r2,-4 802f98: 4884703a and r2,r9,r2 802f9c: 21c6703a and r3,r4,r7 802fa0: 12400104 addi r9,r2,4 802fa4: 1800041e bne r3,zero,802fb8 <_malloc_r+0x25c> 802fa8: 39cf883a add r7,r7,r7 802fac: 4a400104 addi r9,r9,4 802fb0: 21c4703a and r2,r4,r7 802fb4: 103ffc26 beq r2,zero,802fa8 <_malloc_r+0x24c> 802fb8: 480490fa slli r2,r9,3 802fbc: 4817883a mov r11,r9 802fc0: 134d883a add r6,r2,r13 802fc4: 300b883a mov r5,r6 802fc8: 2c000317 ldw r16,12(r5) 802fcc: 81400926 beq r16,r5,802ff4 <_malloc_r+0x298> 802fd0: 02bfff04 movi r10,-4 802fd4: 020003c4 movi r8,15 802fd8: 80800117 ldw r2,4(r16) 802fdc: 1286703a and r3,r2,r10 802fe0: 1c49c83a sub r4,r3,r17 802fe4: 41008016 blt r8,r4,8031e8 <_malloc_r+0x48c> 802fe8: 2000180e bge r4,zero,80304c <_malloc_r+0x2f0> 802fec: 84000317 ldw r16,12(r16) 802ff0: 817ff91e bne r16,r5,802fd8 <_malloc_r+0x27c> 802ff4: 4a400044 addi r9,r9,1 802ff8: 488000cc andi r2,r9,3 802ffc: 29400204 addi r5,r5,8 803000: 103ff11e bne r2,zero,802fc8 <_malloc_r+0x26c> 803004: 588000cc andi r2,r11,3 803008: 31bffe04 addi r6,r6,-8 80300c: 5affffc4 addi r11,r11,-1 803010: 1000e526 beq r2,zero,8033a8 <_malloc_r+0x64c> 803014: 30800217 ldw r2,8(r6) 803018: 11bffa26 beq r2,r6,803004 <_malloc_r+0x2a8> 80301c: 03402034 movhi r13,128 803020: 6b555004 addi r13,r13,21824 803024: 39cf883a add r7,r7,r7 803028: 68c00117 ldw r3,4(r13) 80302c: 19c01e36 bltu r3,r7,8030a8 <_malloc_r+0x34c> 803030: 3800031e bne r7,zero,803040 <_malloc_r+0x2e4> 803034: 00001c06 br 8030a8 <_malloc_r+0x34c> 803038: 39cf883a add r7,r7,r7 80303c: 4a400104 addi r9,r9,4 803040: 19c4703a and r2,r3,r7 803044: 103ffc26 beq r2,zero,803038 <_malloc_r+0x2dc> 803048: 003fdb06 br 802fb8 <_malloc_r+0x25c> 80304c: 80c7883a add r3,r16,r3 803050: 18800117 ldw r2,4(r3) 803054: 82000317 ldw r8,12(r16) 803058: 81c00217 ldw r7,8(r16) 80305c: 10800054 ori r2,r2,1 803060: 9009883a mov r4,r18 803064: 18800115 stw r2,4(r3) 803068: 41c00215 stw r7,8(r8) 80306c: 3a000315 stw r8,12(r7) 803070: 003f7106 br 802e38 <_malloc_r+0xdc> 803074: 88800054 ori r2,r17,1 803078: 844b883a add r5,r16,r17 80307c: 80800115 stw r2,4(r16) 803080: 2905883a add r2,r5,r4 803084: 20c00054 ori r3,r4,1 803088: 61400315 stw r5,12(r12) 80308c: 61400215 stw r5,8(r12) 803090: 11000015 stw r4,0(r2) 803094: 9009883a mov r4,r18 803098: 2b000215 stw r12,8(r5) 80309c: 28c00115 stw r3,4(r5) 8030a0: 2b000315 stw r12,12(r5) 8030a4: 003f6406 br 802e38 <_malloc_r+0xdc> 8030a8: 6d400217 ldw r21,8(r13) 8030ac: 00bfff04 movi r2,-4 8030b0: a8c00117 ldw r3,4(r21) 8030b4: 18ac703a and r22,r3,r2 8030b8: b449c83a sub r4,r22,r17 8030bc: b4400236 bltu r22,r17,8030c8 <_malloc_r+0x36c> 8030c0: 008003c4 movi r2,15 8030c4: 11002316 blt r2,r4,803154 <_malloc_r+0x3f8> 8030c8: d0a01717 ldw r2,-32676(gp) 8030cc: 073fffc4 movi fp,-1 8030d0: b02f883a mov r23,r22 8030d4: 8887883a add r3,r17,r2 8030d8: d0a01617 ldw r2,-32680(gp) 8030dc: ada7883a add r19,r21,r22 8030e0: 1d000404 addi r20,r3,16 8030e4: 17000326 beq r2,fp,8030f4 <_malloc_r+0x398> 8030e8: 18c403c4 addi r3,r3,4111 8030ec: 00bc0004 movi r2,-4096 8030f0: 18a8703a and r20,r3,r2 8030f4: 9009883a mov r4,r18 8030f8: a00b883a mov r5,r20 8030fc: db400015 stw r13,0(sp) 803100: 08035dc0 call 8035dc <_sbrk_r> 803104: 1021883a mov r16,r2 803108: db400017 ldw r13,0(sp) 80310c: 17000426 beq r2,fp,803120 <_malloc_r+0x3c4> 803110: 14c03e2e bgeu r2,r19,80320c <_malloc_r+0x4b0> 803114: 00802034 movhi r2,128 803118: 10955004 addi r2,r2,21824 80311c: a8803b26 beq r21,r2,80320c <_malloc_r+0x4b0> 803120: 68800217 ldw r2,8(r13) 803124: 013fff04 movi r4,-4 803128: 10c00117 ldw r3,4(r2) 80312c: 1906703a and r3,r3,r4 803130: 1c49c83a sub r4,r3,r17 803134: 1c400236 bltu r3,r17,803140 <_malloc_r+0x3e4> 803138: 008003c4 movi r2,15 80313c: 11000516 blt r2,r4,803154 <_malloc_r+0x3f8> 803140: 9009883a mov r4,r18 803144: 0803be80 call 803be8 <__malloc_unlock> 803148: 003f1806 br 802dac <_malloc_r+0x50> 80314c: 4a7fffc4 addi r9,r9,-1 803150: 003f5706 br 802eb0 <_malloc_r+0x154> 803154: 6c000217 ldw r16,8(r13) 803158: 88800054 ori r2,r17,1 80315c: 21000054 ori r4,r4,1 803160: 8447883a add r3,r16,r17 803164: 80800115 stw r2,4(r16) 803168: 19000115 stw r4,4(r3) 80316c: 9009883a mov r4,r18 803170: 68c00215 stw r3,8(r13) 803174: 003f3006 br 802e38 <_malloc_r+0xdc> 803178: 180ad27a srli r5,r3,9 80317c: 1808d0fa srli r4,r3,3 803180: 28000426 beq r5,zero,803194 <_malloc_r+0x438> 803184: 00800104 movi r2,4 803188: 11405836 bltu r2,r5,8032ec <_malloc_r+0x590> 80318c: 1804d1ba srli r2,r3,6 803190: 11000e04 addi r4,r2,56 803194: 200490fa slli r2,r4,3 803198: 01402034 movhi r5,128 80319c: 29555004 addi r5,r5,21824 8031a0: 1351883a add r8,r2,r13 8031a4: 41c00217 ldw r7,8(r8) 8031a8: 3a006d26 beq r7,r8,803360 <_malloc_r+0x604> 8031ac: 38800117 ldw r2,4(r7) 8031b0: 013fff04 movi r4,-4 8031b4: 1104703a and r2,r2,r4 8031b8: 1880052e bgeu r3,r2,8031d0 <_malloc_r+0x474> 8031bc: 39c00217 ldw r7,8(r7) 8031c0: 3a000326 beq r7,r8,8031d0 <_malloc_r+0x474> 8031c4: 38800117 ldw r2,4(r7) 8031c8: 1104703a and r2,r2,r4 8031cc: 18bffb36 bltu r3,r2,8031bc <_malloc_r+0x460> 8031d0: 3a000317 ldw r8,12(r7) 8031d4: 82000315 stw r8,12(r16) 8031d8: 81c00215 stw r7,8(r16) 8031dc: 3c000315 stw r16,12(r7) 8031e0: 44000215 stw r16,8(r8) 8031e4: 003f5f06 br 802f64 <_malloc_r+0x208> 8031e8: 82000317 ldw r8,12(r16) 8031ec: 81c00217 ldw r7,8(r16) 8031f0: 88800054 ori r2,r17,1 8031f4: 844b883a add r5,r16,r17 8031f8: 41c00215 stw r7,8(r8) 8031fc: 3a000315 stw r8,12(r7) 803200: 003f9e06 br 80307c <_malloc_r+0x320> 803204: 48c000c4 addi r3,r9,3 803208: 003f5806 br 802f6c <_malloc_r+0x210> 80320c: 07002034 movhi fp,128 803210: e7154604 addi fp,fp,21784 803214: e0800017 ldw r2,0(fp) 803218: 1505883a add r2,r2,r20 80321c: e0800015 stw r2,0(fp) 803220: 84c05826 beq r16,r19,803384 <_malloc_r+0x628> 803224: d0e01617 ldw r3,-32680(gp) 803228: 00bfffc4 movi r2,-1 80322c: 18805326 beq r3,r2,80337c <_malloc_r+0x620> 803230: e0800017 ldw r2,0(fp) 803234: 84c7c83a sub r3,r16,r19 803238: 10c5883a add r2,r2,r3 80323c: e0800015 stw r2,0(fp) 803240: 80c001cc andi r3,r16,7 803244: 0027883a mov r19,zero 803248: 18000326 beq r3,zero,803258 <_malloc_r+0x4fc> 80324c: 00800204 movi r2,8 803250: 10e7c83a sub r19,r2,r3 803254: 84e1883a add r16,r16,r19 803258: 8505883a add r2,r16,r20 80325c: 1083ffcc andi r2,r2,4095 803260: 00c40004 movi r3,4096 803264: 1887c83a sub r3,r3,r2 803268: 98e7883a add r19,r19,r3 80326c: 9009883a mov r4,r18 803270: 980b883a mov r5,r19 803274: db400015 stw r13,0(sp) 803278: 08035dc0 call 8035dc <_sbrk_r> 80327c: 1007883a mov r3,r2 803280: 00bfffc4 movi r2,-1 803284: db400017 ldw r13,0(sp) 803288: 18804e26 beq r3,r2,8033c4 <_malloc_r+0x668> 80328c: e0800017 ldw r2,0(fp) 803290: 1c07c83a sub r3,r3,r16 803294: 1cc9883a add r4,r3,r19 803298: 14c5883a add r2,r2,r19 80329c: e0800015 stw r2,0(fp) 8032a0: 6c000215 stw r16,8(r13) 8032a4: 20800054 ori r2,r4,1 8032a8: ab404426 beq r21,r13,8033bc <_malloc_r+0x660> 8032ac: 014003c4 movi r5,15 8032b0: 2d801636 bltu r5,r22,80330c <_malloc_r+0x5b0> 8032b4: 00800044 movi r2,1 8032b8: 80800115 stw r2,4(r16) 8032bc: 003f9806 br 803120 <_malloc_r+0x3c4> 8032c0: 00805504 movi r2,340 8032c4: 10c00336 bltu r2,r3,8032d4 <_malloc_r+0x578> 8032c8: 8804d3fa srli r2,r17,15 8032cc: 12401dc4 addi r9,r2,119 8032d0: 003ee806 br 802e74 <_malloc_r+0x118> 8032d4: 00815504 movi r2,1364 8032d8: 02401f84 movi r9,126 8032dc: 10fee536 bltu r2,r3,802e74 <_malloc_r+0x118> 8032e0: 8804d4ba srli r2,r17,18 8032e4: 12401f04 addi r9,r2,124 8032e8: 003ee206 br 802e74 <_malloc_r+0x118> 8032ec: 00800504 movi r2,20 8032f0: 290016c4 addi r4,r5,91 8032f4: 117fa72e bgeu r2,r5,803194 <_malloc_r+0x438> 8032f8: 00801504 movi r2,84 8032fc: 11403a36 bltu r2,r5,8033e8 <_malloc_r+0x68c> 803300: 1804d33a srli r2,r3,12 803304: 11001b84 addi r4,r2,110 803308: 003fa206 br 803194 <_malloc_r+0x438> 80330c: 80800115 stw r2,4(r16) 803310: a8800117 ldw r2,4(r21) 803314: 00fffe04 movi r3,-8 803318: b13ffd04 addi r4,r22,-12 80331c: 20ee703a and r23,r4,r3 803320: 1080004c andi r2,r2,1 803324: 15c4b03a or r2,r2,r23 803328: a8800115 stw r2,4(r21) 80332c: adc7883a add r3,r21,r23 803330: 00800144 movi r2,5 803334: 18800215 stw r2,8(r3) 803338: 18800115 stw r2,4(r3) 80333c: 2dc02436 bltu r5,r23,8033d0 <_malloc_r+0x674> 803340: e0c00017 ldw r3,0(fp) 803344: d0a01517 ldw r2,-32684(gp) 803348: 10c0012e bgeu r2,r3,803350 <_malloc_r+0x5f4> 80334c: d0e01515 stw r3,-32684(gp) 803350: d0a01417 ldw r2,-32688(gp) 803354: 10ff722e bgeu r2,r3,803120 <_malloc_r+0x3c4> 803358: d0e01415 stw r3,-32688(gp) 80335c: 003f7006 br 803120 <_malloc_r+0x3c4> 803360: 2005d0ba srai r2,r4,2 803364: 00c00044 movi r3,1 803368: 29000117 ldw r4,4(r5) 80336c: 1886983a sll r3,r3,r2 803370: 20c8b03a or r4,r4,r3 803374: 29000115 stw r4,4(r5) 803378: 003f9606 br 8031d4 <_malloc_r+0x478> 80337c: d4201615 stw r16,-32680(gp) 803380: 003faf06 br 803240 <_malloc_r+0x4e4> 803384: 8083ffcc andi r2,r16,4095 803388: 103fa61e bne r2,zero,803224 <_malloc_r+0x4c8> 80338c: 00802034 movhi r2,128 803390: 10955004 addi r2,r2,21824 803394: 10c00217 ldw r3,8(r2) 803398: a5c9883a add r4,r20,r23 80339c: 20800054 ori r2,r4,1 8033a0: 18800115 stw r2,4(r3) 8033a4: 003fe606 br 803340 <_malloc_r+0x5e4> 8033a8: 68800117 ldw r2,4(r13) 8033ac: 01c6303a nor r3,zero,r7 8033b0: 10c4703a and r2,r2,r3 8033b4: 68800115 stw r2,4(r13) 8033b8: 003f1806 br 80301c <_malloc_r+0x2c0> 8033bc: 80800115 stw r2,4(r16) 8033c0: 003fdf06 br 803340 <_malloc_r+0x5e4> 8033c4: 0027883a mov r19,zero 8033c8: 8007883a mov r3,r16 8033cc: 003faf06 br 80328c <_malloc_r+0x530> 8033d0: a9400204 addi r5,r21,8 8033d4: 9009883a mov r4,r18 8033d8: db400015 stw r13,0(sp) 8033dc: 08037a80 call 8037a8 <_free_r> 8033e0: db400017 ldw r13,0(sp) 8033e4: 003fd606 br 803340 <_malloc_r+0x5e4> 8033e8: 00805504 movi r2,340 8033ec: 11400336 bltu r2,r5,8033fc <_malloc_r+0x6a0> 8033f0: 1804d3fa srli r2,r3,15 8033f4: 11001dc4 addi r4,r2,119 8033f8: 003f6606 br 803194 <_malloc_r+0x438> 8033fc: 00815504 movi r2,1364 803400: 01001f84 movi r4,126 803404: 117f6336 bltu r2,r5,803194 <_malloc_r+0x438> 803408: 1804d4ba srli r2,r3,18 80340c: 11001f04 addi r4,r2,124 803410: 003f6006 br 803194 <_malloc_r+0x438> 00803414 <memcmp>: 803414: 01c000c4 movi r7,3 803418: 3980032e bgeu r7,r6,803428 <memcmp+0x14> 80341c: 2144b03a or r2,r4,r5 803420: 11c4703a and r2,r2,r7 803424: 10000d26 beq r2,zero,80345c <memcmp+0x48> 803428: 31bfffc4 addi r6,r6,-1 80342c: 00bfffc4 movi r2,-1 803430: 30800826 beq r6,r2,803454 <memcmp+0x40> 803434: 100f883a mov r7,r2 803438: 20c00003 ldbu r3,0(r4) 80343c: 28800003 ldbu r2,0(r5) 803440: 31bfffc4 addi r6,r6,-1 803444: 21000044 addi r4,r4,1 803448: 29400044 addi r5,r5,1 80344c: 18800b1e bne r3,r2,80347c <memcmp+0x68> 803450: 31fff91e bne r6,r7,803438 <memcmp+0x24> 803454: 0005883a mov r2,zero 803458: f800283a ret 80345c: 20c00017 ldw r3,0(r4) 803460: 28800017 ldw r2,0(r5) 803464: 18bff01e bne r3,r2,803428 <memcmp+0x14> 803468: 31bfff04 addi r6,r6,-4 80346c: 21000104 addi r4,r4,4 803470: 29400104 addi r5,r5,4 803474: 39bff936 bltu r7,r6,80345c <memcmp+0x48> 803478: 003feb06 br 803428 <memcmp+0x14> 80347c: 1885c83a sub r2,r3,r2 803480: f800283a ret 00803484 <memcpy>: 803484: 020003c4 movi r8,15 803488: 2007883a mov r3,r4 80348c: 4180032e bgeu r8,r6,80349c <memcpy+0x18> 803490: 2904b03a or r2,r5,r4 803494: 108000cc andi r2,r2,3 803498: 10000c26 beq r2,zero,8034cc <memcpy+0x48> 80349c: 31bfffc4 addi r6,r6,-1 8034a0: 00bfffc4 movi r2,-1 8034a4: 30800726 beq r6,r2,8034c4 <memcpy+0x40> 8034a8: 100f883a mov r7,r2 8034ac: 28800003 ldbu r2,0(r5) 8034b0: 31bfffc4 addi r6,r6,-1 8034b4: 29400044 addi r5,r5,1 8034b8: 18800005 stb r2,0(r3) 8034bc: 18c00044 addi r3,r3,1 8034c0: 31fffa1e bne r6,r7,8034ac <memcpy+0x28> 8034c4: 2005883a mov r2,r4 8034c8: f800283a ret 8034cc: 200f883a mov r7,r4 8034d0: 28800017 ldw r2,0(r5) 8034d4: 29400104 addi r5,r5,4 8034d8: 31bffc04 addi r6,r6,-16 8034dc: 38800015 stw r2,0(r7) 8034e0: 28c00017 ldw r3,0(r5) 8034e4: 39c00104 addi r7,r7,4 8034e8: 29400104 addi r5,r5,4 8034ec: 38c00015 stw r3,0(r7) 8034f0: 28800017 ldw r2,0(r5) 8034f4: 39c00104 addi r7,r7,4 8034f8: 29400104 addi r5,r5,4 8034fc: 38800015 stw r2,0(r7) 803500: 28c00017 ldw r3,0(r5) 803504: 39c00104 addi r7,r7,4 803508: 29400104 addi r5,r5,4 80350c: 38c00015 stw r3,0(r7) 803510: 39c00104 addi r7,r7,4 803514: 41bfee36 bltu r8,r6,8034d0 <memcpy+0x4c> 803518: 00c000c4 movi r3,3 80351c: 1980062e bgeu r3,r6,803538 <memcpy+0xb4> 803520: 28800017 ldw r2,0(r5) 803524: 31bfff04 addi r6,r6,-4 803528: 29400104 addi r5,r5,4 80352c: 38800015 stw r2,0(r7) 803530: 39c00104 addi r7,r7,4 803534: 19bffa36 bltu r3,r6,803520 <memcpy+0x9c> 803538: 3807883a mov r3,r7 80353c: 003fd706 br 80349c <memcpy+0x18> 00803540 <memset>: 803540: 008000c4 movi r2,3 803544: 29403fcc andi r5,r5,255 803548: 2007883a mov r3,r4 80354c: 11801a2e bgeu r2,r6,8035b8 <memset+0x78> 803550: 2084703a and r2,r4,r2 803554: 1000181e bne r2,zero,8035b8 <memset+0x78> 803558: 2806923a slli r3,r5,8 80355c: 200f883a mov r7,r4 803560: 1946b03a or r3,r3,r5 803564: 1804943a slli r2,r3,16 803568: 1886b03a or r3,r3,r2 80356c: 008003c4 movi r2,15 803570: 11800a2e bgeu r2,r6,80359c <memset+0x5c> 803574: 38c00015 stw r3,0(r7) 803578: 39c00104 addi r7,r7,4 80357c: 38c00015 stw r3,0(r7) 803580: 39c00104 addi r7,r7,4 803584: 38c00015 stw r3,0(r7) 803588: 39c00104 addi r7,r7,4 80358c: 38c00015 stw r3,0(r7) 803590: 31bffc04 addi r6,r6,-16 803594: 39c00104 addi r7,r7,4 803598: 11bff636 bltu r2,r6,803574 <memset+0x34> 80359c: 008000c4 movi r2,3 8035a0: 1180042e bgeu r2,r6,8035b4 <memset+0x74> 8035a4: 38c00015 stw r3,0(r7) 8035a8: 31bfff04 addi r6,r6,-4 8035ac: 39c00104 addi r7,r7,4 8035b0: 11bffc36 bltu r2,r6,8035a4 <memset+0x64> 8035b4: 3807883a mov r3,r7 8035b8: 31bfffc4 addi r6,r6,-1 8035bc: 00bfffc4 movi r2,-1 8035c0: 30800426 beq r6,r2,8035d4 <memset+0x94> 8035c4: 19400005 stb r5,0(r3) 8035c8: 31bfffc4 addi r6,r6,-1 8035cc: 18c00044 addi r3,r3,1 8035d0: 30bffc1e bne r6,r2,8035c4 <memset+0x84> 8035d4: 2005883a mov r2,r4 8035d8: f800283a ret 008035dc <_sbrk_r>: 8035dc: defffe04 addi sp,sp,-8 8035e0: dc000015 stw r16,0(sp) 8035e4: 2021883a mov r16,r4 8035e8: 2809883a mov r4,r5 8035ec: dfc00115 stw ra,4(sp) 8035f0: d0201b15 stw zero,-32660(gp) 8035f4: 0803c040 call 803c04 <sbrk> 8035f8: 1007883a mov r3,r2 8035fc: 00bfffc4 movi r2,-1 803600: 18800526 beq r3,r2,803618 <_sbrk_r+0x3c> 803604: 1805883a mov r2,r3 803608: dfc00117 ldw ra,4(sp) 80360c: dc000017 ldw r16,0(sp) 803610: dec00204 addi sp,sp,8 803614: f800283a ret 803618: d0a01b17 ldw r2,-32660(gp) 80361c: 103ff926 beq r2,zero,803604 <_sbrk_r+0x28> 803620: 80800015 stw r2,0(r16) 803624: 003ff706 br 803604 <_sbrk_r+0x28> 00803628 <strlen>: 803628: 208000cc andi r2,r4,3 80362c: 200f883a mov r7,r4 803630: 1000101e bne r2,zero,803674 <strlen+0x4c> 803634: 20800017 ldw r2,0(r4) 803638: 01bfbff4 movhi r6,65279 80363c: 31bfbfc4 addi r6,r6,-257 803640: 01602074 movhi r5,32897 803644: 29602004 addi r5,r5,-32640 803648: 00000206 br 803654 <strlen+0x2c> 80364c: 21000104 addi r4,r4,4 803650: 20800017 ldw r2,0(r4) 803654: 0086303a nor r3,zero,r2 803658: 1185883a add r2,r2,r6 80365c: 10c4703a and r2,r2,r3 803660: 1144703a and r2,r2,r5 803664: 103ff926 beq r2,zero,80364c <strlen+0x24> 803668: 20800007 ldb r2,0(r4) 80366c: 10000326 beq r2,zero,80367c <strlen+0x54> 803670: 21000044 addi r4,r4,1 803674: 20800007 ldb r2,0(r4) 803678: 103ffd1e bne r2,zero,803670 <strlen+0x48> 80367c: 21c5c83a sub r2,r4,r7 803680: f800283a ret 00803684 <_malloc_trim_r>: 803684: defffb04 addi sp,sp,-20 803688: dcc00015 stw r19,0(sp) 80368c: 04c02034 movhi r19,128 803690: 9cd55004 addi r19,r19,21824 803694: dc000315 stw r16,12(sp) 803698: dc400215 stw r17,8(sp) 80369c: dc800115 stw r18,4(sp) 8036a0: 2823883a mov r17,r5 8036a4: 2021883a mov r16,r4 8036a8: dfc00415 stw ra,16(sp) 8036ac: 0803bcc0 call 803bcc <__malloc_lock> 8036b0: 98800217 ldw r2,8(r19) 8036b4: 8009883a mov r4,r16 8036b8: 000b883a mov r5,zero 8036bc: 10c00117 ldw r3,4(r2) 8036c0: 00bfff04 movi r2,-4 8036c4: 18a4703a and r18,r3,r2 8036c8: 9463c83a sub r17,r18,r17 8036cc: 8c43fbc4 addi r17,r17,4079 8036d0: 8822d33a srli r17,r17,12 8036d4: 00840004 movi r2,4096 8036d8: 8c7fffc4 addi r17,r17,-1 8036dc: 8822933a slli r17,r17,12 8036e0: 88800616 blt r17,r2,8036fc <_malloc_trim_r+0x78> 8036e4: 08035dc0 call 8035dc <_sbrk_r> 8036e8: 98c00217 ldw r3,8(r19) 8036ec: 8009883a mov r4,r16 8036f0: 044bc83a sub r5,zero,r17 8036f4: 1c87883a add r3,r3,r18 8036f8: 18800926 beq r3,r2,803720 <_malloc_trim_r+0x9c> 8036fc: 0803be80 call 803be8 <__malloc_unlock> 803700: 0005883a mov r2,zero 803704: dfc00417 ldw ra,16(sp) 803708: dc000317 ldw r16,12(sp) 80370c: dc400217 ldw r17,8(sp) 803710: dc800117 ldw r18,4(sp) 803714: dcc00017 ldw r19,0(sp) 803718: dec00504 addi sp,sp,20 80371c: f800283a ret 803720: 8009883a mov r4,r16 803724: 08035dc0 call 8035dc <_sbrk_r> 803728: 944dc83a sub r6,r18,r17 80372c: 00ffffc4 movi r3,-1 803730: 8009883a mov r4,r16 803734: 000b883a mov r5,zero 803738: 01c02034 movhi r7,128 80373c: 39d54604 addi r7,r7,21784 803740: 31800054 ori r6,r6,1 803744: 10c00926 beq r2,r3,80376c <_malloc_trim_r+0xe8> 803748: 38800017 ldw r2,0(r7) 80374c: 98c00217 ldw r3,8(r19) 803750: 8009883a mov r4,r16 803754: 1445c83a sub r2,r2,r17 803758: 38800015 stw r2,0(r7) 80375c: 19800115 stw r6,4(r3) 803760: 0803be80 call 803be8 <__malloc_unlock> 803764: 00800044 movi r2,1 803768: 003fe606 br 803704 <_malloc_trim_r+0x80> 80376c: 08035dc0 call 8035dc <_sbrk_r> 803770: 99400217 ldw r5,8(r19) 803774: 100d883a mov r6,r2 803778: 8009883a mov r4,r16 80377c: 1165c83a sub r18,r2,r5 803780: 008003c4 movi r2,15 803784: 90c00054 ori r3,r18,1 803788: 14bfdc0e bge r2,r18,8036fc <_malloc_trim_r+0x78> 80378c: 28c00115 stw r3,4(r5) 803790: d0e01617 ldw r3,-32680(gp) 803794: 00802034 movhi r2,128 803798: 10954604 addi r2,r2,21784 80379c: 30c7c83a sub r3,r6,r3 8037a0: 10c00015 stw r3,0(r2) 8037a4: 003fd506 br 8036fc <_malloc_trim_r+0x78> 008037a8 <_free_r>: 8037a8: defffd04 addi sp,sp,-12 8037ac: dc000115 stw r16,4(sp) 8037b0: dc400015 stw r17,0(sp) 8037b4: dfc00215 stw ra,8(sp) 8037b8: 2821883a mov r16,r5 8037bc: 2023883a mov r17,r4 8037c0: 28003226 beq r5,zero,80388c <_free_r+0xe4> 8037c4: 0803bcc0 call 803bcc <__malloc_lock> 8037c8: 82bffe04 addi r10,r16,-8 8037cc: 51400117 ldw r5,4(r10) 8037d0: 00bfff84 movi r2,-2 8037d4: 03002034 movhi r12,128 8037d8: 63155004 addi r12,r12,21824 8037dc: 2892703a and r9,r5,r2 8037e0: 524d883a add r6,r10,r9 8037e4: 30c00117 ldw r3,4(r6) 8037e8: 61000217 ldw r4,8(r12) 8037ec: 00bfff04 movi r2,-4 8037f0: 1896703a and r11,r3,r2 8037f4: 21804e26 beq r4,r6,803930 <_free_r+0x188> 8037f8: 2880004c andi r2,r5,1 8037fc: 32c00115 stw r11,4(r6) 803800: 000b883a mov r5,zero 803804: 1000091e bne r2,zero,80382c <_free_r+0x84> 803808: 50c00017 ldw r3,0(r10) 80380c: 60800204 addi r2,r12,8 803810: 50d5c83a sub r10,r10,r3 803814: 51000217 ldw r4,8(r10) 803818: 48d3883a add r9,r9,r3 80381c: 20807426 beq r4,r2,8039f0 <_free_r+0x248> 803820: 52000317 ldw r8,12(r10) 803824: 41000215 stw r4,8(r8) 803828: 22000315 stw r8,12(r4) 80382c: 32c7883a add r3,r6,r11 803830: 18800117 ldw r2,4(r3) 803834: 2808c03a cmpne r4,r5,zero 803838: 1080004c andi r2,r2,1 80383c: 1000061e bne r2,zero,803858 <_free_r+0xb0> 803840: 4ad3883a add r9,r9,r11 803844: 20001626 beq r4,zero,8038a0 <_free_r+0xf8> 803848: 30c00217 ldw r3,8(r6) 80384c: 32000317 ldw r8,12(r6) 803850: 40c00215 stw r3,8(r8) 803854: 1a000315 stw r8,12(r3) 803858: 48800054 ori r2,r9,1 80385c: 5247883a add r3,r10,r9 803860: 50800115 stw r2,4(r10) 803864: 1a400015 stw r9,0(r3) 803868: 20001726 beq r4,zero,8038c8 <_free_r+0x120> 80386c: 8809883a mov r4,r17 803870: 02002034 movhi r8,128 803874: 420efa04 addi r8,r8,15336 803878: dfc00217 ldw ra,8(sp) 80387c: dc000117 ldw r16,4(sp) 803880: dc400017 ldw r17,0(sp) 803884: dec00304 addi sp,sp,12 803888: 4000683a jmp r8 80388c: dfc00217 ldw ra,8(sp) 803890: dc000117 ldw r16,4(sp) 803894: dc400017 ldw r17,0(sp) 803898: dec00304 addi sp,sp,12 80389c: f800283a ret 8038a0: 30c00217 ldw r3,8(r6) 8038a4: 00802034 movhi r2,128 8038a8: 10955204 addi r2,r2,21832 8038ac: 18bfe71e bne r3,r2,80384c <_free_r+0xa4> 8038b0: 1a800315 stw r10,12(r3) 8038b4: 1a800215 stw r10,8(r3) 8038b8: 01000044 movi r4,1 8038bc: 50c00215 stw r3,8(r10) 8038c0: 50c00315 stw r3,12(r10) 8038c4: 003fe406 br 803858 <_free_r+0xb0> 8038c8: 00807fc4 movi r2,511 8038cc: 12402b36 bltu r2,r9,80397c <_free_r+0x1d4> 8038d0: 4806d0fa srli r3,r9,3 8038d4: 01802034 movhi r6,128 8038d8: 31955004 addi r6,r6,21824 8038dc: 00800044 movi r2,1 8038e0: 180890fa slli r4,r3,3 8038e4: 1807d0ba srai r3,r3,2 8038e8: 31400117 ldw r5,4(r6) 8038ec: 2191883a add r8,r4,r6 8038f0: 41c00217 ldw r7,8(r8) 8038f4: 10c4983a sll r2,r2,r3 8038f8: 52000315 stw r8,12(r10) 8038fc: 51c00215 stw r7,8(r10) 803900: 288ab03a or r5,r5,r2 803904: 3a800315 stw r10,12(r7) 803908: 31400115 stw r5,4(r6) 80390c: 42800215 stw r10,8(r8) 803910: 8809883a mov r4,r17 803914: 02002034 movhi r8,128 803918: 420efa04 addi r8,r8,15336 80391c: dfc00217 ldw ra,8(sp) 803920: dc000117 ldw r16,4(sp) 803924: dc400017 ldw r17,0(sp) 803928: dec00304 addi sp,sp,12 80392c: 4000683a jmp r8 803930: 2880004c andi r2,r5,1 803934: 4ad3883a add r9,r9,r11 803938: 1000071e bne r2,zero,803958 <_free_r+0x1b0> 80393c: 50c00017 ldw r3,0(r10) 803940: 50d5c83a sub r10,r10,r3 803944: 52000317 ldw r8,12(r10) 803948: 51c00217 ldw r7,8(r10) 80394c: 48d3883a add r9,r9,r3 803950: 41c00215 stw r7,8(r8) 803954: 3a000315 stw r8,12(r7) 803958: d0a01817 ldw r2,-32672(gp) 80395c: 48c00054 ori r3,r9,1 803960: 62800215 stw r10,8(r12) 803964: 50c00115 stw r3,4(r10) 803968: 48bfc036 bltu r9,r2,80386c <_free_r+0xc4> 80396c: d1601717 ldw r5,-32676(gp) 803970: 8809883a mov r4,r17 803974: 08036840 call 803684 <_malloc_trim_r> 803978: 003fbc06 br 80386c <_free_r+0xc4> 80397c: 4808d27a srli r4,r9,9 803980: 4806d0fa srli r3,r9,3 803984: 2000151e bne r4,zero,8039dc <_free_r+0x234> 803988: 180490fa slli r2,r3,3 80398c: 01402034 movhi r5,128 803990: 29555004 addi r5,r5,21824 803994: 1311883a add r8,r2,r12 803998: 41c00217 ldw r7,8(r8) 80399c: 3a001e26 beq r7,r8,803a18 <_free_r+0x270> 8039a0: 38800117 ldw r2,4(r7) 8039a4: 00ffff04 movi r3,-4 8039a8: 10c4703a and r2,r2,r3 8039ac: 4880052e bgeu r9,r2,8039c4 <_free_r+0x21c> 8039b0: 39c00217 ldw r7,8(r7) 8039b4: 3a000326 beq r7,r8,8039c4 <_free_r+0x21c> 8039b8: 38800117 ldw r2,4(r7) 8039bc: 10c4703a and r2,r2,r3 8039c0: 48bffb36 bltu r9,r2,8039b0 <_free_r+0x208> 8039c4: 3a000317 ldw r8,12(r7) 8039c8: 52000315 stw r8,12(r10) 8039cc: 51c00215 stw r7,8(r10) 8039d0: 3a800315 stw r10,12(r7) 8039d4: 42800215 stw r10,8(r8) 8039d8: 003fcd06 br 803910 <_free_r+0x168> 8039dc: 00800104 movi r2,4 8039e0: 11000536 bltu r2,r4,8039f8 <_free_r+0x250> 8039e4: 4804d1ba srli r2,r9,6 8039e8: 10c00e04 addi r3,r2,56 8039ec: 003fe606 br 803988 <_free_r+0x1e0> 8039f0: 01400044 movi r5,1 8039f4: 003f8d06 br 80382c <_free_r+0x84> 8039f8: 00800504 movi r2,20 8039fc: 20c016c4 addi r3,r4,91 803a00: 113fe12e bgeu r2,r4,803988 <_free_r+0x1e0> 803a04: 00801504 movi r2,84 803a08: 11000a36 bltu r2,r4,803a34 <_free_r+0x28c> 803a0c: 4804d33a srli r2,r9,12 803a10: 10c01b84 addi r3,r2,110 803a14: 003fdc06 br 803988 <_free_r+0x1e0> 803a18: 1805d0ba srai r2,r3,2 803a1c: 00c00044 movi r3,1 803a20: 29000117 ldw r4,4(r5) 803a24: 1886983a sll r3,r3,r2 803a28: 20c8b03a or r4,r4,r3 803a2c: 29000115 stw r4,4(r5) 803a30: 003fe506 br 8039c8 <_free_r+0x220> 803a34: 00805504 movi r2,340 803a38: 11000336 bltu r2,r4,803a48 <_free_r+0x2a0> 803a3c: 4804d3fa srli r2,r9,15 803a40: 10c01dc4 addi r3,r2,119 803a44: 003fd006 br 803988 <_free_r+0x1e0> 803a48: 00815504 movi r2,1364 803a4c: 00c01f84 movi r3,126 803a50: 113fcd36 bltu r2,r4,803988 <_free_r+0x1e0> 803a54: 4804d4ba srli r2,r9,18 803a58: 10c01f04 addi r3,r2,124 803a5c: 003fca06 br 803988 <_free_r+0x1e0> 00803a60 <udivmodsi4>: 803a60: 00800044 movi r2,1 803a64: 000f883a mov r7,zero 803a68: 2900082e bgeu r5,r4,803a8c <udivmodsi4+0x2c> 803a6c: 28000716 blt r5,zero,803a8c <udivmodsi4+0x2c> 803a70: 294b883a add r5,r5,r5 803a74: 1085883a add r2,r2,r2 803a78: 29000e2e bgeu r5,r4,803ab4 <udivmodsi4+0x54> 803a7c: 1007003a cmpeq r3,r2,zero 803a80: 1800081e bne r3,zero,803aa4 <udivmodsi4+0x44> 803a84: 283ffa0e bge r5,zero,803a70 <udivmodsi4+0x10> 803a88: 1800061e bne r3,zero,803aa4 <udivmodsi4+0x44> 803a8c: 21400236 bltu r4,r5,803a98 <udivmodsi4+0x38> 803a90: 2149c83a sub r4,r4,r5 803a94: 388eb03a or r7,r7,r2 803a98: 1004d07a srli r2,r2,1 803a9c: 280ad07a srli r5,r5,1 803aa0: 103ffa1e bne r2,zero,803a8c <udivmodsi4+0x2c> 803aa4: 3000011e bne r6,zero,803aac <udivmodsi4+0x4c> 803aa8: 3809883a mov r4,r7 803aac: 2005883a mov r2,r4 803ab0: f800283a ret 803ab4: 1007003a cmpeq r3,r2,zero 803ab8: 183ff426 beq r3,zero,803a8c <udivmodsi4+0x2c> 803abc: 003ff906 br 803aa4 <udivmodsi4+0x44> 00803ac0 <__divsi3>: 803ac0: defffe04 addi sp,sp,-8 803ac4: dc000015 stw r16,0(sp) 803ac8: dfc00115 stw ra,4(sp) 803acc: 000d883a mov r6,zero 803ad0: 0021883a mov r16,zero 803ad4: 20000816 blt r4,zero,803af8 <__divsi3+0x38> 803ad8: 28000a16 blt r5,zero,803b04 <__divsi3+0x44> 803adc: 0803a600 call 803a60 <udivmodsi4> 803ae0: 80000126 beq r16,zero,803ae8 <__divsi3+0x28> 803ae4: 0085c83a sub r2,zero,r2 803ae8: dfc00117 ldw ra,4(sp) 803aec: dc000017 ldw r16,0(sp) 803af0: dec00204 addi sp,sp,8 803af4: f800283a ret 803af8: 0109c83a sub r4,zero,r4 803afc: 0021003a cmpeq r16,zero,zero 803b00: 283ff60e bge r5,zero,803adc <__divsi3+0x1c> 803b04: 014bc83a sub r5,zero,r5 803b08: 8021003a cmpeq r16,r16,zero 803b0c: 003ff306 br 803adc <__divsi3+0x1c> 00803b10 <__modsi3>: 803b10: defffe04 addi sp,sp,-8 803b14: dc000015 stw r16,0(sp) 803b18: dfc00115 stw ra,4(sp) 803b1c: 01800044 movi r6,1 803b20: 0021883a mov r16,zero 803b24: 20000816 blt r4,zero,803b48 <__modsi3+0x38> 803b28: 28000a16 blt r5,zero,803b54 <__modsi3+0x44> 803b2c: 0803a600 call 803a60 <udivmodsi4> 803b30: 80000126 beq r16,zero,803b38 <__modsi3+0x28> 803b34: 0085c83a sub r2,zero,r2 803b38: dfc00117 ldw ra,4(sp) 803b3c: dc000017 ldw r16,0(sp) 803b40: dec00204 addi sp,sp,8 803b44: f800283a ret 803b48: 0109c83a sub r4,zero,r4 803b4c: 3021883a mov r16,r6 803b50: 283ff60e bge r5,zero,803b2c <__modsi3+0x1c> 803b54: 014bc83a sub r5,zero,r5 803b58: 003ff406 br 803b2c <__modsi3+0x1c> 00803b5c <__udivsi3>: 803b5c: 000d883a mov r6,zero 803b60: 02002034 movhi r8,128 803b64: 420e9804 addi r8,r8,14944 803b68: 4000683a jmp r8 00803b6c <__umodsi3>: 803b6c: 01800044 movi r6,1 803b70: 02002034 movhi r8,128 803b74: 420e9804 addi r8,r8,14944 803b78: 4000683a jmp r8 00803b7c <alt_sim_halt>: #endif static ALT_ALWAYS_INLINE void alt_sim_halt(int exit_code) { 803b7c: defffd04 addi sp,sp,-12 803b80: df000215 stw fp,8(sp) 803b84: d839883a mov fp,sp 803b88: e1000015 stw r4,0(fp) int r2 = exit_code; 803b8c: e0800017 ldw r2,0(fp) 803b90: e0800115 stw r2,4(fp) #if defined(NIOS2_HAS_DEBUG_STUB) && (defined(ALT_BREAK_ON_EXIT) || defined(ALT_PROVIDE_GMON)) int r3 = (1 << 2); #ifdef ALT_PROVIDE_GMON extern unsigned int alt_gmon_data[]; int r4 = (int)alt_gmon_data; r3 |= (1 << 4); usleep(100000); #define ALT_GMON_DATA ,"D04"(r4) #else #define ALT_GMON_DATA #endif __asm__ volatile ("wrctl ctl6, %0" : : "r"(1), "D02"(r2) ); __asm__ volatile ("\n0:\n\taddi %0,%0, -1\n\tbgt %0,zero,0b" : : "r" (ALT_CPU_FREQ/100) ); /* Delay for >30ms */ __asm__ volatile ("break 2" : : "D02"(r2), "D03"(r3) ALT_GMON_DATA ); #else __asm__ volatile ("wrctl ctl6, %0" : : "r"(1), "D02"(r2) ); 803b94: 00c00044 movi r3,1 803b98: e0800117 ldw r2,4(fp) 803b9c: 180171ba wrctl ctl6,r3 #endif } 803ba0: df000217 ldw fp,8(sp) 803ba4: dec00304 addi sp,sp,12 803ba8: f800283a ret 00803bac <_exit>: * ALT_EXIT is mapped onto the _exit() system call in alt_syscall.h */ void ALT_EXIT (int exit_code) { 803bac: defffd04 addi sp,sp,-12 803bb0: dfc00215 stw ra,8(sp) 803bb4: df000115 stw fp,4(sp) 803bb8: d839883a mov fp,sp 803bbc: e1000015 stw r4,0(fp) /* ALT_LOG - please see HAL/inc/alt_log_printf.h for details */ ALT_LOG_PRINT_BOOT("[alt_exit.c] Entering _exit() function.\r\n"); ALT_LOG_PRINT_BOOT("[alt_exit.c] Exit code from main was %d.\r\n",exit_code); /* Stop all other threads */ ALT_LOG_PRINT_BOOT("[alt_exit.c] Calling ALT_OS_STOP().\r\n"); ALT_OS_STOP(); /* Provide notification to the simulator that we've stopped */ ALT_LOG_PRINT_BOOT("[alt_exit.c] Calling ALT_SIM_HALT().\r\n"); ALT_SIM_HALT(exit_code); 803bc0: e1000017 ldw r4,0(fp) 803bc4: 0803b7c0 call 803b7c <alt_sim_halt> /* spin forever, since there's no where to go back to */ ALT_LOG_PRINT_BOOT("[alt_exit.c] Spinning forever.\r\n"); while (1); 803bc8: 003fff06 br 803bc8 <_exit+0x1c> 00803bcc <__malloc_lock>: * this requires that malloc is never called by an interrupt service routine. */ void __malloc_lock ( struct _reent *_r ) { 803bcc: defffe04 addi sp,sp,-8 803bd0: df000115 stw fp,4(sp) 803bd4: d839883a mov fp,sp 803bd8: e1000015 stw r4,0(fp) 803bdc: df000117 ldw fp,4(sp) 803be0: dec00204 addi sp,sp,8 803be4: f800283a ret 00803be8 <__malloc_unlock>: } /* * */ void __malloc_unlock ( struct _reent *_r ) { 803be8: defffe04 addi sp,sp,-8 803bec: df000115 stw fp,4(sp) 803bf0: d839883a mov fp,sp 803bf4: e1000015 stw r4,0(fp) 803bf8: df000117 ldw fp,4(sp) 803bfc: dec00204 addi sp,sp,8 803c00: f800283a ret 00803c04 <sbrk>: caddr_t ALT_SBRK (int incr) __attribute__ ((no_instrument_function )); caddr_t ALT_SBRK (int incr) { 803c04: defff904 addi sp,sp,-28 803c08: df000615 stw fp,24(sp) 803c0c: d839883a mov fp,sp 803c10: e1000015 stw r4,0(fp) alt_irq_disable_all (void) { alt_irq_context context; NIOS2_READ_STATUS (context); 803c14: 0005303a rdctl r2,status 803c18: e0800415 stw r2,16(fp) NIOS2_WRITE_STATUS (0); 803c1c: 0001703a wrctl status,zero 803c20: e0800417 ldw r2,16(fp) 803c24: e0800315 stw r2,12(fp) 803c28: e0800317 ldw r2,12(fp) 803c2c: e0800115 stw r2,4(fp) alt_irq_context context; char *prev_heap_end; context = alt_irq_disable_all(); /* Always return data aligned on a word boundary */ heap_end = (char *)(((unsigned int)heap_end + 3) & ~3); 803c30: d0a01917 ldw r2,-32668(gp) 803c34: 10c000c4 addi r3,r2,3 803c38: 00bfff04 movi r2,-4 803c3c: 1884703a and r2,r3,r2 803c40: d0a01915 stw r2,-32668(gp) #ifdef ALT_MAX_HEAP_BYTES /* * User specified a maximum heap size. Return -1 if it would * be exceeded by this sbrk call. */ if (((heap_end + incr) - __alt_heap_start) > ALT_MAX_HEAP_BYTES) { alt_irq_enable_all(context); return (caddr_t)-1; } #else if ((heap_end + incr) > __alt_heap_limit) { 803c44: d0e01917 ldw r3,-32668(gp) 803c48: e0800017 ldw r2,0(fp) 803c4c: 1887883a add r3,r3,r2 803c50: 00804034 movhi r2,256 803c54: 10800004 addi r2,r2,0 803c58: 10c0072e bgeu r2,r3,803c78 <sbrk+0x74> */ static ALT_INLINE void ALT_ALWAYS_INLINE alt_irq_enable_all (alt_irq_context context) { 803c5c: e0800117 ldw r2,4(fp) 803c60: e0800415 stw r2,16(fp) NIOS2_WRITE_STATUS (context); 803c64: e0800417 ldw r2,16(fp) 803c68: 1001703a wrctl status,r2 alt_irq_enable_all(context); return (caddr_t)-1; 803c6c: 00bfffc4 movi r2,-1 803c70: e0800515 stw r2,20(fp) 803c74: 00000c06 br 803ca8 <sbrk+0xa4> } #endif prev_heap_end = heap_end; 803c78: d0a01917 ldw r2,-32668(gp) 803c7c: e0800215 stw r2,8(fp) heap_end += incr; 803c80: d0e01917 ldw r3,-32668(gp) 803c84: e0800017 ldw r2,0(fp) 803c88: 1885883a add r2,r3,r2 803c8c: d0a01915 stw r2,-32668(gp) */ static ALT_INLINE void ALT_ALWAYS_INLINE alt_irq_enable_all (alt_irq_context context) { 803c90: e0800117 ldw r2,4(fp) 803c94: e0800415 stw r2,16(fp) NIOS2_WRITE_STATUS (context); 803c98: e0800417 ldw r2,16(fp) 803c9c: 1001703a wrctl status,r2 #ifdef ALT_STACK_CHECK /* * If the stack and heap are contiguous then extending the heap reduces the * space available for the stack. If we are still using the default stack * then adjust the stack limit to note this, while checking for stack * pointer overflow. * If the stack limit isn't pointing at the top of the heap then the code * is using a different stack so none of this needs to be done. */ if (alt_stack_limit() == prev_heap_end) { if (alt_stack_pointer() <= heap_end) alt_report_stack_overflow(); alt_set_stack_limit(heap_end); } #ifdef ALT_EXCEPTION_STACK /* * If we are executing from the exception stack then compare against the * stack we switched away from as well. The exception stack is a fixed * size so doesn't need to be checked. */ if (alt_exception_old_stack_limit == prev_heap_end) { if (alt_exception_old_stack_limit <= heap_end) alt_report_stack_overflow(); alt_exception_old_stack_limit = heap_end; } #endif #endif alt_irq_enable_all(context); return (caddr_t) prev_heap_end; 803ca0: e0800217 ldw r2,8(fp) 803ca4: e0800515 stw r2,20(fp) } 803ca8: e0800517 ldw r2,20(fp) 803cac: df000617 ldw fp,24(sp) 803cb0: dec00704 addi sp,sp,28 803cb4: f800283a ret
Maintained by John Loomis, last updated 13 November 2008