Download: asm1.zip
./asm1.sh
.include "./nios_macros.m"
.data
.asciz "University of Dayton"
table:
.word 21, 37, 18, 14, 42, 11, 19
.text
.global main
.type main, @function
main:
movi r2,10 # a = 10
movi r3,14 # b = 14
sub r4,r3,r2 # c = b - a
movi r6,11 # e = 11
movi r7,6 # f = 6
/* Generate: g = (b + c) - (e + f) */
add r8,r3,r4 # g = (b+c)
add r9,r7,r8 # tmp = (e+f)
sub r8,r8,r9 # g = g - tmp
addi r9,r8,3 # h = g + 3
/* do some logic operations */
and r4,r2,r3 # c = a & b
or r5,r2,r3 # d = a | b
nor r6,r2,r3 # e = ~(a | b)
xor r7,r2,r3 # f = a ^ b
andi r8,r2,0x3f # g = a & 0x3f
end:
br end /* wait here once the program has completed */
.end
#!/bin/sh nios2-elf-size blank_project_1.elf > asm1.size.txt nios2-elf-objdump -dS blank_project_1.elf > asm1.disassemble.txt nios2-elf-objdump -h blank_project_1.elf > asm1.headers.txt nios2-elf-objcopy -S -O binary blank_project_1.elf asm1.bin nios2-elf-nm blank_project_1.elf > asm1.symbols.txt od -Ax -j0x824 -txz asm1.bin > asm1.od.txt
text data bss dec hex filename 2084 308 4 2396 95c blank_project_1.elf
blank_project_1.elf: file format elf32-littlenios2
Sections:
Idx Name Size VMA LMA File off Algn
0 .entry 00000020 00000000 00000000 00000074 2**5
CONTENTS, ALLOC, LOAD, READONLY, CODE
1 .exceptions 00000000 00000020 00000020 000009cc 2**0
CONTENTS
2 .text 000007e4 00000020 00000020 00000094 2**2
CONTENTS, ALLOC, LOAD, READONLY, CODE
3 .rodata 00000020 00000804 00000804 00000878 2**2
CONTENTS, ALLOC, LOAD, READONLY, DATA
4 .rwdata 00000134 00000824 00000824 00000898 2**2
CONTENTS, ALLOC, LOAD, DATA, SMALL_DATA
5 .bss 00000004 00000958 00000958 000009cc 2**2
ALLOC, SMALL_DATA
6 .onchip_memory_0 00000000 0000095c 0000095c 000009cc 2**0
CONTENTS
7 .comment 00000331 00000000 00000000 000009cc 2**0
CONTENTS, READONLY
8 .debug_aranges 00000228 00000000 00000000 00000d00 2**3
CONTENTS, READONLY, DEBUGGING
9 .debug_pubnames 00000303 00000000 00000000 00000f28 2**0
CONTENTS, READONLY, DEBUGGING
10 .debug_info 0000367d 00000000 00000000 0000122b 2**0
CONTENTS, READONLY, DEBUGGING
11 .debug_abbrev 00001078 00000000 00000000 000048a8 2**0
CONTENTS, READONLY, DEBUGGING
12 .debug_line 0000350f 00000000 00000000 00005920 2**0
CONTENTS, READONLY, DEBUGGING
13 .debug_frame 000002ac 00000000 00000000 00008e30 2**2
CONTENTS, READONLY, DEBUGGING
14 .debug_str 00000cff 00000000 00000000 000090dc 2**0
CONTENTS, READONLY, DEBUGGING
15 .debug_alt_sim_info 00000030 00000000 00000000 00009ddc 2**2
CONTENTS, READONLY, DEBUGGING
16 .debug_ranges 00000030 00000030 00000030 00009e0c 2**0
CONTENTS, READONLY, DEBUGGING
00000804 A __CTOR_END__
00000804 A __CTOR_LIST__
00008000 A __alt_data_end
00000000 A __alt_mem_onchip_memory_0
00008000 A __alt_stack_pointer
0000095c A __bss_end
00000958 A __bss_start
w __errno
00000000 T __reset
00000230 T _do_ctors
00000958 A _edata
0000095c A _end
000007f4 T _exit
00008930 A _gp
00000954 G _impure_ptr
00000001 a _nios2_macros_
00000020 T _start
00000938 G alt_argc
00000934 G alt_argv
00000100 T alt_avalon_jtag_uart_read
0000017c T alt_avalon_jtag_uart_write
00000940 G alt_dev_list
000001bc T alt_dev_llist_insert
000008b4 G alt_dev_null
000001b4 t alt_dev_null_write
00000930 G alt_envp
00000950 G alt_errno
00000884 G alt_fd_list
00000524 T alt_find_dev
000005b0 T alt_find_file
00000948 G alt_fs_list
00000678 T alt_get_fd
000002f0 T alt_io_redirect
000000a0 T alt_main
0000093c G alt_max_fd
00000278 t alt_open_fd
00000500 T alt_release_fd
000000e8 T alt_sys_init
0000095c A end
0000009c t end
00000958 B errno
000007f4 T exit
000008dc g impure_data
00000858 g jtag_uart_0
00000064 T main
00000798 T memcmp
00000384 T open
000007d4 T strlen
00000839 g table
blank_project_1.elf: file format elf32-littlenios2
Disassembly of section .entry:
00000000 <__reset>:
*/
#if NIOS2_ICACHE_SIZE > 0x8000
movhi r2, %hi(NIOS2_ICACHE_SIZE)
#else
movui r2, NIOS2_ICACHE_SIZE
0: 00840014 movui r2,4096
#endif
0:
initi r2
4: 1001483a initi r2
addi r2, r2, -NIOS2_ICACHE_LINE_SIZE
8: 10bff804 addi r2,r2,-32
bgt r2, zero, 0b
c: 00bffd16 blt zero,r2,4 <_nios2_macros_+0x3>
1:
/*
* The following block of debug information tells the simulator 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 /* NIOS2_ICACHE_SIZE > 0 */
/*
* Having initialised the cache, call the entry point for the .text
* section.
*/
#endif /* ALT_SIM_OPTIMIZE */
movhi r1, %hiadj(_start)
10: 00400034 movhi at,0
addi r1, r1, %lo(_start)
14: 08400804 addi at,at,32
jmp r1
18: 0800683a jmp at
1c: 00000000 call 0 <__alt_mem_onchip_memory_0>
Disassembly of section .text:
00000020 <_start>:
.size __reset, . - __reset
#endif
/*
* Start of the .text section, and also the code entry point when
* the code is executed by a loader rather than directly from reset.
*/
.section .text
.align 2
.globl _start
.type _start, @function
_start:
/*
* If ALT_SIM_OPTIMIZE is defined this code WILL NOT RUN ON HARDWARE
* This defined removes the initialisation of the instruction
* and data caches at run time. It is assumed that this is done by the
* simulation model
*/
#ifndef ALT_SIM_OPTIMIZE
/*
* After initializing the instruction cache, we must initialize the data
* cache.
*/
#if NIOS2_DCACHE_SIZE > 0
/*
* The assumption here is that 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
20: 00820014 movui r2,2048
#endif
0:
initd 0(r2)
24: 10000033 initd 0(r2)
addi r2, r2, -NIOS2_DCACHE_LINE_SIZE
28: 10bfff04 addi r2,r2,-4
bgt r2, zero, 0b
2c: 00bffd16 blt zero,r2,24 <_start+0x4>
1:
/*
* The following block of debug information tells the simulator 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 /* NIOS2_DCACHE_SIZE > 0 */
#endif /* ALT_SIM_OPTIMIZE */
/*
* Now that the caches have been cleaned, set up the stack pointer.
* The value provided by the linker is assumed to be correctly aligned.
*/
/* ALT_LOG - see altera_hal/HAL/inc/sys/alt_log_printf.h */
ALT_LOG_PUTS(alt_log_msg_cache)
ALT_LOG_PUTS(alt_log_msg_stackpointer)
movhi sp, %hiadj(__alt_stack_pointer)
30: 06c00074 movhi sp,1
addi sp, sp, %lo(__alt_stack_pointer)
34: dee00004 addi sp,sp,-32768
/* set up the global pointer. */
movhi gp, %hiadj(_gp)
38: 06800074 movhi gp,1
addi gp, gp, %lo(_gp)
3c: d6a24c04 addi gp,gp,-30416
#ifndef ALT_SIM_OPTIMIZE
/*
* Clear bss.
*
* 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.
*/
/* ALT_LOG - see altera_hal/HAL/inc/sys/alt_log_printf.h */
ALT_LOG_PUTS(alt_log_msg_bss)
movhi r2, %hiadj(__bss_start)
40: 00800034 movhi r2,0
addi r2, r2, %lo(__bss_start)
44: 10825604 addi r2,r2,2392
movhi r3, %hiadj(__bss_end)
48: 00c00034 movhi r3,0
addi r3, r3, %lo(__bss_end)
4c: 18c25704 addi r3,r3,2396
beq r2, r3, 1f
50: 10c00326 beq r2,r3,60 <_start+0x40>
0:
stw zero, (r2)
54: 10000015 stw zero,0(r2)
addi r2, r2, 4
58: 10800104 addi r2,r2,4
bltu r2, r3, 0b
5c: 10fffd36 bltu r2,r3,54 <_start+0x34>
1:
/*
* The following block of debug information tells the simulator 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 */
/*
* When running from flash. Load the data sections to RAM, if there
* are any sections to load.
*
* 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).
*/
#ifdef ALT_NO_BOOTLOADER
#if ALT_LOAD_SECTIONS
#ifdef ALT_STACK_CHECK
mov et, zero
#endif
call alt_load
#endif /* ALT_LOAD_SECTIONS */
#endif /* ALT_NO_BOOTLOADER */
#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
/* ALT_LOG - see altera_hal/HAL/inc/sys/alt_log_printf.h */
ALT_LOG_PUTS(alt_log_msg_alt_main)
/* call the C entry point. */
call alt_main
60: 00000a00 call a0 <alt_main>
00000064 <main>:
64: 00800284 movi r2,10
68: 00c00384 movi r3,14
6c: 1889c83a sub r4,r3,r2
70: 018002c4 movi r6,11
74: 01c00184 movi r7,6
78: 1911883a add r8,r3,r4
7c: 3a13883a add r9,r7,r8
80: 4251c83a sub r8,r8,r9
84: 424000c4 addi r9,r8,3
88: 10c8703a and r4,r2,r3
8c: 10cab03a or r5,r2,r3
90: 10cc303a nor r6,r2,r3
94: 10cef03a xor r7,r2,r3
98: 12000fcc andi r8,r2,63
0000009c <end>:
9c: 003fff06 br 9c <end>
000000a0 <alt_main>:
* the users application, i.e. main().
*/
void alt_main (void)
{
a0: deffff04 addi sp,sp,-4
a4: dfc00015 stw ra,0(sp)
static ALT_INLINE void ALT_ALWAYS_INLINE
alt_irq_init (const void* base)
{
NIOS2_WRITE_IENABLE (0);
a8: 000170fa wrctl ienable,zero
NIOS2_WRITE_STATUS (NIOS2_STATUS_PIE_MSK);
ac: 00800044 movi r2,1
b0: 1001703a wrctl status,r2
/* 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");
/* Initialise the interrupt controller. */
alt_irq_init (ALT_IRQ_BASE);
/* Initialise the operating system */
ALT_LOG_PRINT_BOOT("[alt_main.c] Done alt_irq_init, calling alt_os_init.\r\n");
ALT_OS_INIT();
/*
* Initialise 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);
/* Initialise the device drivers/software components. */
ALT_LOG_PRINT_BOOT("[alt_main.c] Calling alt_sys_init.\r\n");
alt_sys_init ();
b4: 00000e80 call e8 <alt_sys_init>
/*
* Redirect stdout etc. to the apropriate devices now that the devices have
* been initialised. This is only done if the user has requested that the
* channels been directed away from /dev/null - which is how the channels
* are configured by default. Making the call to alt_io_redirect conditional
* allows this function to be excluded from optomised executables when it
* is unecessary.
*/
ALT_LOG_PRINT_BOOT("[alt_main.c] Done alt_sys_init. Redirecting IO.\r\n");
if (strcmp (ALT_STDOUT, "/dev/null") ||
strcmp (ALT_STDIN, "/dev/null") ||
strcmp (ALT_STDERR, "/dev/null"))
{
alt_io_redirect (ALT_STDOUT, ALT_STDIN, ALT_STDERR);
b8: 01000034 movhi r4,0
bc: 21020104 addi r4,r4,2052
c0: 200b883a mov r5,r4
c4: 200d883a mov r6,r4
c8: 00002f00 call 2f0 <alt_io_redirect>
}
/* Call the C++ constructors */
ALT_LOG_PRINT_BOOT("[alt_main.c] Calling C++ constructors.\r\n");
_do_ctors ();
cc: 00002300 call 230 <_do_ctors>
/*
* 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.
*/
#ifndef ALT_NO_CLEAN_EXIT
atexit (_do_dtors);
#endif
/*
* Finally, call main(). The return code is then passed to a subsequent
* call to exit().
*/
ALT_LOG_PRINT_BOOT("[alt_main.c] Calling main.\r\n");
exit (main (alt_argc, alt_argv, alt_envp));
d0: d1200217 ldw r4,-32760(gp)
d4: d1600117 ldw r5,-32764(gp)
d8: d1a00017 ldw r6,-32768(gp)
dc: 00000640 call 64 <main>
e0: 1009883a mov r4,r2
e4: 00007f40 call 7f4 <_exit>
000000e8 <alt_sys_init>:
extern int alt_fs_reg (alt_dev* dev);
static ALT_INLINE int alt_dev_reg (alt_dev* dev)
{
extern alt_llist alt_dev_list;
e8: 01000034 movhi r4,0
ec: 21021604 addi r4,r4,2136
f0: d1600404 addi r5,gp,-32752
f4: 02000034 movhi r8,0
f8: 42006f04 addi r8,r8,444
fc: 4000683a jmp r8
00000100 <alt_avalon_jtag_uart_read>:
*/
int alt_avalon_jtag_uart_read(alt_fd* fd, char * buffer, int space)
{
alt_avalon_jtag_uart_dev * dev = (alt_avalon_jtag_uart_dev*) fd->dev;
100: 20800017 ldw r2,0(r4)
unsigned int base = dev->base;
char * ptr = buffer;
char * end = buffer + space;
104: 298f883a add r7,r5,r6
108: 2807883a mov r3,r5
10c: 12000a17 ldw r8,40(r2)
while (ptr < end)
{
unsigned int data = IORD_ALTERA_AVALON_JTAG_UART_DATA(base);
if (data & ALTERA_AVALON_JTAG_UART_DATA_RVALID_MSK)
*ptr++ = (data & ALTERA_AVALON_JTAG_UART_DATA_DATA_MSK) >> ALTERA_AVALON_JTAG_UART_DATA_DATA_OFST;
else if (ptr != buffer)
break;
else if(fd->fd_flags & O_NONBLOCK)
break;
110: 29c0072e bgeu r5,r7,130 <alt_avalon_jtag_uart_read+0x30>
114: 41800037 ldwio r6,0(r8)
118: 3004d3fa srli r2,r6,15
11c: 1080004c andi r2,r2,1
120: 10000726 beq r2,zero,140 <alt_avalon_jtag_uart_read+0x40>
124: 19800005 stb r6,0(r3)
128: 18c00044 addi r3,r3,1
12c: 19fff936 bltu r3,r7,114 <alt_avalon_jtag_uart_read+0x14>
}
if (ptr != buffer)
130: 19400b26 beq r3,r5,160 <alt_avalon_jtag_uart_read+0x60>
return ptr - buffer;
134: 1947c83a sub r3,r3,r5
else if (fd->fd_flags & O_NONBLOCK)
return -EWOULDBLOCK;
else
return -EIO;
}
138: 1805883a mov r2,r3
13c: f800283a ret
140: 197ffc1e bne r3,r5,134 <alt_avalon_jtag_uart_read+0x34>
144: 20800217 ldw r2,8(r4)
148: 1004d3ba srli r2,r2,14
14c: 1080004c andi r2,r2,1
150: 1005003a cmpeq r2,r2,zero
154: 103ff626 beq r2,zero,130 <alt_avalon_jtag_uart_read+0x30>
158: 19ffee36 bltu r3,r7,114 <alt_avalon_jtag_uart_read+0x14>
15c: 003ff406 br 130 <alt_avalon_jtag_uart_read+0x30>
160: 20800217 ldw r2,8(r4)
164: 00fffd44 movi r3,-11
168: 1004d3ba srli r2,r2,14
16c: 1080004c andi r2,r2,1
170: 103ff11e bne r2,zero,138 <alt_avalon_jtag_uart_read+0x38>
174: 00fffec4 movi r3,-5
178: 003fef06 br 138 <alt_avalon_jtag_uart_read+0x38>
0000017c <alt_avalon_jtag_uart_write>:
/* Write routine. The small version blocks when there is no space to write
* into, so it's performance will be very bad if you are writing more than
* one FIFOs worth of data. But you said you didn't want to use interrupts :-)
*/
int alt_avalon_jtag_uart_write(alt_fd* fd, const char * ptr, int count)
{
alt_avalon_jtag_uart_dev * dev = (alt_avalon_jtag_uart_dev*) fd->dev;
17c: 20800017 ldw r2,0(r4)
unsigned int base = dev->base;
const char * end = ptr + count;
180: 2989883a add r4,r5,r6
184: 11c00a17 ldw r7,40(r2)
while (ptr < end)
if ((IORD_ALTERA_AVALON_JTAG_UART_CONTROL(base) & ALTERA_AVALON_JTAG_UART_CONTROL_WSPACE_MSK) != 0)
IOWR_ALTERA_AVALON_JTAG_UART_DATA(base, *ptr++);
188: 2900082e bgeu r5,r4,1ac <alt_avalon_jtag_uart_write+0x30>
18c: 38c00104 addi r3,r7,4
190: 18800037 ldwio r2,0(r3)
194: 10bfffec andhi r2,r2,65535
198: 10000326 beq r2,zero,1a8 <alt_avalon_jtag_uart_write+0x2c>
19c: 28800007 ldb r2,0(r5)
1a0: 38800035 stwio r2,0(r7)
1a4: 29400044 addi r5,r5,1
1a8: 293ff936 bltu r5,r4,190 <alt_avalon_jtag_uart_write+0x14>
return count;
}
1ac: 3005883a mov r2,r6
1b0: f800283a ret
000001b4 <alt_dev_null_write>:
static int alt_dev_null_write (alt_fd* fd, const char* ptr, int len)
{
return len;
}
1b4: 3005883a mov r2,r6
1b8: f800283a ret
000001bc <alt_dev_llist_insert>:
*
*/
int alt_dev_llist_insert (alt_dev_llist* dev, alt_llist* list)
{
1bc: deffff04 addi sp,sp,-4
1c0: dfc00015 stw ra,0(sp)
/*
* check that the device exists, and that it has a valid name.
*/
if (!dev || !dev->name)
1c4: 20000326 beq r4,zero,1d4 <alt_dev_llist_insert+0x18>
1c8: 20800217 ldw r2,8(r4)
{
ALT_ERRNO = EINVAL;
return -EINVAL;
}
/*
* register the device.
*/
alt_llist_insert(list, &dev->llist);
return 0;
1cc: 000d883a mov r6,zero
1d0: 10000a1e bne r2,zero,1fc <alt_dev_llist_insert+0x40>
extern int errno;
static ALT_INLINE int* alt_get_errno(void)
{
return ((alt_errno) ? alt_errno() : &errno);
1d4: d0a00817 ldw r2,-32736(gp)
1d8: d0e00a04 addi r3,gp,-32728
1dc: 1000111e bne r2,zero,224 <alt_dev_llist_insert+0x68>
1e0: 01bffa84 movi r6,-22
extern int errno;
static ALT_INLINE int* alt_get_errno(void)
{
1e4: 00800584 movi r2,22
1e8: 18800015 stw r2,0(r3)
}
1ec: 3005883a mov r2,r6
1f0: dfc00017 ldw ra,0(sp)
1f4: dec00104 addi sp,sp,4
1f8: f800283a ret
static ALT_INLINE void ALT_ALWAYS_INLINE alt_llist_insert(alt_llist* list,
alt_llist* entry)
{
entry->previous = list;
entry->next = list->next;
1fc: 28c00017 ldw r3,0(r5)
200: 21400115 stw r5,4(r4)
204: 20c00015 stw r3,0(r4)
list->next->previous = entry;
208: 28800017 ldw r2,0(r5)
list->next = entry;
20c: 29000015 stw r4,0(r5)
210: 11000115 stw r4,4(r2)
214: 3005883a mov r2,r6
218: dfc00017 ldw ra,0(sp)
21c: dec00104 addi sp,sp,4
220: f800283a ret
extern int errno;
static ALT_INLINE int* alt_get_errno(void)
{
return ((alt_errno) ? alt_errno() : &errno);
224: 103ee83a callr r2
228: 1007883a mov r3,r2
22c: 003fec06 br 1e0 <alt_dev_llist_insert+0x24>
00000230 <_do_ctors>:
* Run the C++ static constructors.
*/
void _do_ctors(void)
{
230: defffd04 addi sp,sp,-12
234: dc000115 stw r16,4(sp)
238: dc400015 stw r17,0(sp)
constructor* ctor;
for (ctor = &__CTOR_END__[-1]; ctor >= __CTOR_LIST__; ctor--)
23c: 04000034 movhi r16,0
240: 84020004 addi r16,r16,2048
244: 04400034 movhi r17,0
248: 8c420104 addi r17,r17,2052
24c: dfc00215 stw ra,8(sp)
250: 84400436 bltu r16,r17,264 <_do_ctors+0x34>
(*ctor) ();
254: 80800017 ldw r2,0(r16)
258: 843fff04 addi r16,r16,-4
25c: 103ee83a callr r2
260: 847ffc2e bgeu r16,r17,254 <_do_ctors+0x24>
264: dfc00217 ldw ra,8(sp)
268: dc000117 ldw r16,4(sp)
26c: dc400017 ldw r17,0(sp)
270: dec00304 addi sp,sp,12
274: f800283a ret
00000278 <alt_open_fd>:
* remains unchanged.
*/
static void alt_open_fd(alt_fd* fd, const char* name, int flags, int mode)
{
278: defffe04 addi sp,sp,-8
27c: dc000015 stw r16,0(sp)
280: 2021883a mov r16,r4
int old;
old = open (name, flags, mode);
284: 2809883a mov r4,r5
288: 300b883a mov r5,r6
28c: 380d883a mov r6,r7
290: dfc00115 stw ra,4(sp)
294: 00003840 call 384 <open>
if (old >= 0)
{
fd->dev = alt_fd_list[old].dev;
298: 11400324 muli r5,r2,12
29c: 00c00034 movhi r3,0
2a0: 18c22104 addi r3,r3,2180
fd->priv = alt_fd_list[old].priv;
fd->fd_flags = alt_fd_list[old].fd_flags;
alt_release_fd (old);
2a4: 1009883a mov r4,r2
2a8: 28cb883a add r5,r5,r3
2ac: 10000c16 blt r2,zero,2e0 <alt_open_fd+0x68>
2b0: 28800217 ldw r2,8(r5)
2b4: 28c00017 ldw r3,0(r5)
2b8: 29400117 ldw r5,4(r5)
2bc: 02000034 movhi r8,0
2c0: 42014004 addi r8,r8,1280
2c4: 80800215 stw r2,8(r16)
2c8: 80c00015 stw r3,0(r16)
2cc: 81400115 stw r5,4(r16)
}
}
2d0: dfc00117 ldw ra,4(sp)
2d4: dc000017 ldw r16,0(sp)
2d8: dec00204 addi sp,sp,8
2dc: 4000683a jmp r8
2e0: dfc00117 ldw ra,4(sp)
2e4: dc000017 ldw r16,0(sp)
2e8: dec00204 addi sp,sp,8
2ec: f800283a ret
000002f0 <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)
{
2f0: defffa04 addi sp,sp,-24
2f4: dc000415 stw r16,16(sp)
2f8: dc800215 stw r18,8(sp)
/* Redirect the channels */
alt_open_fd (&alt_fd_list[STDOUT_FILENO], stdout_dev, O_WRONLY, 0777);
2fc: 04000034 movhi r16,0
300: 84022404 addi r16,r16,2192
304: 04807fc4 movi r18,511
308: dd800015 stw r22,0(sp)
30c: 05800044 movi r22,1
310: dc400315 stw r17,12(sp)
314: dd000115 stw r20,4(sp)
318: 3023883a mov r17,r6
31c: 2829883a mov r20,r5
320: b00d883a mov r6,r22
324: 200b883a mov r5,r4
328: 900f883a mov r7,r18
32c: 8009883a mov r4,r16
330: dfc00515 stw ra,20(sp)
334: 00002780 call 278 <alt_open_fd>
alt_open_fd (&alt_fd_list[STDIN_FILENO], stdin_dev, O_RDONLY, 0777);
338: a00b883a mov r5,r20
33c: 813ffd04 addi r4,r16,-12
340: 900f883a mov r7,r18
344: 000d883a mov r6,zero
348: 00002780 call 278 <alt_open_fd>
alt_open_fd (&alt_fd_list[STDERR_FILENO], stderr_dev, O_WRONLY, 0777);
34c: 02000034 movhi r8,0
350: 42009e04 addi r8,r8,632
354: 81000304 addi r4,r16,12
358: 880b883a mov r5,r17
35c: b00d883a mov r6,r22
360: 900f883a mov r7,r18
364: dfc00517 ldw ra,20(sp)
368: dc000417 ldw r16,16(sp)
36c: dc400317 ldw r17,12(sp)
370: dc800217 ldw r18,8(sp)
374: dd000117 ldw r20,4(sp)
378: dd800017 ldw r22,0(sp)
37c: dec00604 addi sp,sp,24
380: 4000683a jmp r8
00000384 <open>:
* ALT_OPEN is mapped onto the open() system call in alt_syscall.h
*/
int ALT_OPEN (const char* file, int flags, int mode)
{
384: defff804 addi sp,sp,-32
388: dd000215 stw r20,8(sp)
38c: 2829883a mov r20,r5
alt_dev* dev;
alt_fd* fd;
int index = -1;
int status = -ENODEV;
int isafs = 0;
/*
* Check the device list, to see if a device with a matching name is
* registered.
*/
if (!(dev = alt_find_dev (file, &alt_dev_list)))
390: d1600404 addi r5,gp,-32752
394: dc000615 stw r16,24(sp)
398: dc400515 stw r17,20(sp)
39c: dc800415 stw r18,16(sp)
3a0: dcc00315 stw r19,12(sp)
3a4: dd400115 stw r21,4(sp)
3a8: dd800015 stw r22,0(sp)
3ac: dfc00715 stw ra,28(sp)
3b0: 302d883a mov r22,r6
3b4: 202b883a mov r21,r4
3b8: 00005240 call 524 <alt_find_dev>
3bc: 1021883a mov r16,r2
3c0: 04bfffc4 movi r18,-1
3c4: 047ffb44 movi r17,-19
3c8: 0027883a mov r19,zero
3cc: 10003f26 beq r2,zero,4cc <open+0x148>
{
/* No matching device, so try the filesystem list */
dev = alt_find_file (file);
isafs = 1;
}
/*
* If a matching device or filesystem is found, allocate a file descriptor.
*/
if (dev)
3d0: 80003526 beq r16,zero,4a8 <open+0x124>
{
if ((index = alt_get_fd (dev)) < 0)
3d4: 8009883a mov r4,r16
3d8: 00006780 call 678 <alt_get_fd>
3dc: 1025883a mov r18,r2
{
status = index;
3e0: 1023883a mov r17,r2
3e4: 10002f16 blt r2,zero,4a4 <open+0x120>
}
else
{
fd = &alt_fd_list[index];
3e8: 10800324 muli r2,r2,12
3ec: 02000034 movhi r8,0
3f0: 42022104 addi r8,r8,2180
fd->fd_flags = (flags & ~ALT_FD_FLAGS_MASK);
3f4: 00d00034 movhi r3,16384
3f8: 18ffffc4 addi r3,r3,-1
/* If this is a device, ensure it isn't already locked */
if (isafs || ((status = alt_file_locked (fd)) >= 0))
3fc: 9808c03a cmpne r4,r19,zero
400: 120f883a add r7,r2,r8
404: a0c4703a and r2,r20,r3
408: 2000111e bne r4,zero,450 <open+0xcc>
40c: 39800017 ldw r6,0(r7)
410: d1600317 ldw r5,-32756(gp)
414: 10900034 orhi r2,r2,16384
418: 4007883a mov r3,r8
41c: 0009883a mov r4,zero
420: 38800215 stw r2,8(r7)
424: 00000206 br 430 <open+0xac>
428: 18c00304 addi r3,r3,12
42c: 29002c36 bltu r5,r4,4e0 <open+0x15c>
430: 18800017 ldw r2,0(r3)
434: 21000044 addi r4,r4,1
438: 11bffb1e bne r2,r6,428 <open+0xa4>
43c: 18800217 ldw r2,8(r3)
440: 103ff90e bge r2,zero,428 <open+0xa4>
444: 19fff826 beq r3,r7,428 <open+0xa4>
448: 00bffcc4 movi r2,-13
44c: 00002506 br 4e4 <open+0x160>
450: 38800215 stw r2,8(r7)
{
/*
* 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;
454: 80800317 ldw r2,12(r16)
458: 10000c1e bne r2,zero,48c <open+0x108>
}
}
}
else
{
status = -ENODEV;
}
/* Allocation failed, so clean up and return an error */
if (status < 0)
{
alt_release_fd (index);
ALT_ERRNO = -status;
return -1;
}
/* return the reference upon success */
return index;
45c: 9007883a mov r3,r18
}
460: 1805883a mov r2,r3
464: dfc00717 ldw ra,28(sp)
468: dc000617 ldw r16,24(sp)
46c: dc400517 ldw r17,20(sp)
470: dc800417 ldw r18,16(sp)
474: dcc00317 ldw r19,12(sp)
478: dd000217 ldw r20,8(sp)
47c: dd400117 ldw r21,4(sp)
480: dd800017 ldw r22,0(sp)
484: dec00804 addi sp,sp,32
488: f800283a ret
48c: 3809883a mov r4,r7
490: a80b883a mov r5,r21
494: a00d883a mov r6,r20
498: b00f883a mov r7,r22
49c: 103ee83a callr r2
4a0: 1023883a mov r17,r2
4a4: 883fed0e bge r17,zero,45c <open+0xd8>
4a8: 9009883a mov r4,r18
4ac: 00005000 call 500 <alt_release_fd>
extern int errno;
static ALT_INLINE int* alt_get_errno(void)
{
return ((alt_errno) ? alt_errno() : &errno);
4b0: d0a00817 ldw r2,-32736(gp)
4b4: d1200a04 addi r4,gp,-32728
4b8: 10000e1e bne r2,zero,4f4 <open+0x170>
4bc: 0445c83a sub r2,zero,r17
4c0: 00ffffc4 movi r3,-1
extern int errno;
static ALT_INLINE int* alt_get_errno(void)
{
4c4: 20800015 stw r2,0(r4)
4c8: 003fe506 br 460 <open+0xdc>
4cc: a809883a mov r4,r21
4d0: 00005b00 call 5b0 <alt_find_file>
4d4: 1021883a mov r16,r2
4d8: 04c00044 movi r19,1
4dc: 003fbc06 br 3d0 <open+0x4c>
4e0: 0005883a mov r2,zero
4e4: 1023883a mov r17,r2
4e8: 103fda0e bge r2,zero,454 <open+0xd0>
4ec: 883fdb0e bge r17,zero,45c <open+0xd8>
4f0: 003fed06 br 4a8 <open+0x124>
extern int errno;
static ALT_INLINE int* alt_get_errno(void)
{
return ((alt_errno) ? alt_errno() : &errno);
4f4: 103ee83a callr r2
4f8: 1009883a mov r4,r2
4fc: 003fef06 br 4bc <open+0x138>
00000500 <alt_release_fd>:
*/
void alt_release_fd (int fd)
{
if (fd > 2)
500: 00800084 movi r2,2
{
alt_fd_list[fd].fd_flags = 0;
504: 20c00324 muli r3,r4,12
508: 1100050e bge r2,r4,520 <alt_release_fd+0x20>
50c: 00800034 movhi r2,0
510: 10822104 addi r2,r2,2180
514: 1885883a add r2,r3,r2
alt_fd_list[fd].dev = 0;
518: 10000015 stw zero,0(r2)
51c: 10000215 stw zero,8(r2)
520: f800283a ret
00000524 <alt_find_dev>:
* be found.
*/
alt_dev* alt_find_dev(const char* name, alt_llist* llist)
{
524: defffb04 addi sp,sp,-20
528: dc400215 stw r17,8(sp)
52c: dc800115 stw r18,4(sp)
530: dcc00015 stw r19,0(sp)
534: dfc00415 stw ra,16(sp)
538: dc000315 stw r16,12(sp)
alt_dev* next = (alt_dev*) llist->next;
53c: 2c000017 ldw r16,0(r5)
540: 2823883a mov r17,r5
544: 2027883a mov r19,r4
alt_32 len;
len = strlen(name) + 1;
548: 00007d40 call 7d4 <strlen>
54c: 14800044 addi r18,r2,1
/*
* 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)
{
/*
* memcmp() is used here rather than strcmp() in order to reduce the size
* of the executable.
*/
if (!memcmp (next->name, name, len))
{
/* match found */
return next;
}
next = (alt_dev*) next->llist.next;
550: 84400726 beq r16,r17,570 <alt_find_dev+0x4c>
554: 81000217 ldw r4,8(r16)
558: 980b883a mov r5,r19
55c: 900d883a mov r6,r18
560: 00007980 call 798 <memcmp>
564: 10000a26 beq r2,zero,590 <alt_find_dev+0x6c>
568: 84000017 ldw r16,0(r16)
56c: 847ff91e bne r16,r17,554 <alt_find_dev+0x30>
}
/* No match found */
return NULL;
570: 0005883a mov r2,zero
}
574: dfc00417 ldw ra,16(sp)
578: dc000317 ldw r16,12(sp)
57c: dc400217 ldw r17,8(sp)
580: dc800117 ldw r18,4(sp)
584: dcc00017 ldw r19,0(sp)
588: dec00504 addi sp,sp,20
58c: f800283a ret
590: 8005883a mov r2,r16
594: dfc00417 ldw ra,16(sp)
598: dc000317 ldw r16,12(sp)
59c: dc400217 ldw r17,8(sp)
5a0: dc800117 ldw r18,4(sp)
5a4: dcc00017 ldw r19,0(sp)
5a8: dec00504 addi sp,sp,20
5ac: f800283a ret
000005b0 <alt_find_file>:
* "/myfilesystem/junk.txt" would match: "/myfilesystem", but not: "/myfile".
*/
alt_dev* alt_find_file (const char* name)
{
5b0: defffa04 addi sp,sp,-24
5b4: dc000415 stw r16,16(sp)
alt_dev* next = (alt_dev*) alt_fs_list.next;
5b8: d4200617 ldw r16,-32744(gp)
5bc: dd000015 stw r20,0(sp)
5c0: d5200604 addi r20,gp,-32744
5c4: dc800215 stw r18,8(sp)
5c8: dfc00515 stw ra,20(sp)
5cc: dc400315 stw r17,12(sp)
5d0: dcc00115 stw r19,4(sp)
5d4: 2025883a mov r18,r4
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)
{
len = strlen(next->name);
if (next->name[len-1] == '/')
{
len -= 1;
}
if (((name[len] == '/') || (name[len] == '\0')) &&
!memcmp (next->name, name, len))
{
/* match found */
return next;
}
next = (alt_dev*) next->llist.next;
5d8: 85001526 beq r16,r20,630 <alt_find_file+0x80>
5dc: 04c00bc4 movi r19,47
5e0: 00000806 br 604 <alt_find_file+0x54>
5e4: 9185883a add r2,r18,r6
5e8: 10800007 ldb r2,0(r2)
5ec: 14c00126 beq r2,r19,5f4 <alt_find_file+0x44>
5f0: 1000021e bne r2,zero,5fc <alt_find_file+0x4c>
5f4: 00007980 call 798 <memcmp>
5f8: 10001626 beq r2,zero,654 <alt_find_file+0xa4>
5fc: 84000017 ldw r16,0(r16)
600: 85000b26 beq r16,r20,630 <alt_find_file+0x80>
604: 84400217 ldw r17,8(r16)
608: 8809883a mov r4,r17
60c: 00007d40 call 7d4 <strlen>
610: 100d883a mov r6,r2
614: 8885883a add r2,r17,r2
618: 10ffffc7 ldb r3,-1(r2)
61c: 8809883a mov r4,r17
620: 900b883a mov r5,r18
624: 1cffef1e bne r3,r19,5e4 <alt_find_file+0x34>
628: 31bfffc4 addi r6,r6,-1
62c: 003fed06 br 5e4 <alt_find_file+0x34>
}
/* No match found */
return NULL;
630: 0005883a mov r2,zero
}
634: dfc00517 ldw ra,20(sp)
638: dc000417 ldw r16,16(sp)
63c: dc400317 ldw r17,12(sp)
640: dc800217 ldw r18,8(sp)
644: dcc00117 ldw r19,4(sp)
648: dd000017 ldw r20,0(sp)
64c: dec00604 addi sp,sp,24
650: f800283a ret
654: 8005883a mov r2,r16
658: dfc00517 ldw ra,20(sp)
65c: dc000417 ldw r16,16(sp)
660: dc400317 ldw r17,12(sp)
664: dc800217 ldw r18,8(sp)
668: dcc00117 ldw r19,4(sp)
66c: dd000017 ldw r20,0(sp)
670: dec00604 addi sp,sp,24
674: f800283a ret
00000678 <alt_get_fd>:
* negative value indicates failure.
*/
int alt_get_fd (alt_dev* dev)
{
678: d1e00317 ldw r7,-32756(gp)
alt_32 i;
int rc = -EMFILE;
67c: 023ffa04 movi r8,-24
/*
* 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++)
680: 000b883a mov r5,zero
684: 018000c4 movi r6,3
688: 00c00034 movhi r3,0
68c: 18c22104 addi r3,r3,2180
{
if (!alt_fd_list[i].dev)
690: 18800017 ldw r2,0(r3)
694: 10000626 beq r2,zero,6b0 <alt_get_fd+0x38>
698: 29400044 addi r5,r5,1
69c: 18c00304 addi r3,r3,12
6a0: 317ffb0e bge r6,r5,690 <alt_get_fd+0x18>
{
alt_fd_list[i].dev = dev;
if (i > alt_max_fd)
{
alt_max_fd = i;
}
rc = i;
goto alt_get_fd_exit;
}
}
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;
}
6a4: 4005883a mov r2,r8
6a8: d1e00315 stw r7,-32756(gp)
6ac: f800283a ret
6b0: 19000015 stw r4,0(r3)
6b4: 3940010e bge r7,r5,6bc <alt_get_fd+0x44>
6b8: 280f883a mov r7,r5
6bc: 2811883a mov r8,r5
6c0: 4005883a mov r2,r8
6c4: d1e00315 stw r7,-32756(gp)
6c8: f800283a ret
6cc: d0a00917 ldw r2,-32732(gp)
6d0: defff804 addi sp,sp,-32
6d4: dd800015 stw r22,0(sp)
6d8: dfc00715 stw ra,28(sp)
6dc: dc000615 stw r16,24(sp)
6e0: dc400515 stw r17,20(sp)
6e4: dc800415 stw r18,16(sp)
6e8: dcc00315 stw r19,12(sp)
6ec: dd000215 stw r20,8(sp)
6f0: dd400115 stw r21,4(sp)
6f4: 15000c17 ldw r20,48(r2)
6f8: 202d883a mov r22,r4
6fc: a0002426 beq r20,zero,790 <alt_get_fd+0x118>
700: a0800117 ldw r2,4(r20)
704: a5402204 addi r21,r20,136
708: 0027883a mov r19,zero
70c: 143fffc4 addi r16,r2,-1
710: 8006803a cmplt r3,r16,zero
714: 1800021e bne r3,zero,720 <alt_get_fd+0xa8>
718: 00800044 movi r2,1
71c: 1426983a sll r19,r2,r16
720: 1800191e bne r3,zero,788 <alt_get_fd+0x110>
724: 800490ba slli r2,r16,2
728: 1025883a mov r18,r2
72c: 1505883a add r2,r2,r20
730: 14400204 addi r17,r2,8
734: 00000806 br 758 <alt_get_fd+0xe0>
738: 88800017 ldw r2,0(r17)
73c: 29400017 ldw r5,0(r5)
740: 843fffc4 addi r16,r16,-1
744: 94bfff04 addi r18,r18,-4
748: 103ee83a callr r2
74c: 8c7fff04 addi r17,r17,-4
750: 9827d07a srai r19,r19,1
754: 80000c16 blt r16,zero,788 <alt_get_fd+0x110>
758: a8802017 ldw r2,128(r21)
75c: 954b883a add r5,r18,r21
760: b009883a mov r4,r22
764: 14c4703a and r2,r2,r19
768: 103ff31e bne r2,zero,738 <alt_get_fd+0xc0>
76c: 88800017 ldw r2,0(r17)
770: 843fffc4 addi r16,r16,-1
774: 94bfff04 addi r18,r18,-4
778: 103ee83a callr r2
77c: 8c7fff04 addi r17,r17,-4
780: 9827d07a srai r19,r19,1
784: 803ff40e bge r16,zero,758 <alt_get_fd+0xe0>
788: a5000017 ldw r20,0(r20)
78c: a03fdc1e bne r20,zero,700 <alt_get_fd+0x88>
790: b009883a mov r4,r22
794: 00007f40 call 7f4 <_exit>
00000798 <memcmp>:
798: 31bfffc4 addi r6,r6,-1
79c: 00bfffc4 movi r2,-1
7a0: 30800826 beq r6,r2,7c4 <memcmp+0x2c>
7a4: 100f883a mov r7,r2
7a8: 20c00003 ldbu r3,0(r4)
7ac: 28800003 ldbu r2,0(r5)
7b0: 31bfffc4 addi r6,r6,-1
7b4: 21000044 addi r4,r4,1
7b8: 29400044 addi r5,r5,1
7bc: 1880031e bne r3,r2,7cc <memcmp+0x34>
7c0: 31fff91e bne r6,r7,7a8 <memcmp+0x10>
7c4: 0005883a mov r2,zero
7c8: f800283a ret
7cc: 1885c83a sub r2,r3,r2
7d0: f800283a ret
000007d4 <strlen>:
7d4: 20800007 ldb r2,0(r4)
7d8: 2007883a mov r3,r4
7dc: 10000326 beq r2,zero,7ec <strlen+0x18>
7e0: 21000044 addi r4,r4,1
7e4: 20800007 ldb r2,0(r4)
7e8: 103ffd1e bne r2,zero,7e0 <strlen+0xc>
7ec: 20c5c83a sub r2,r4,r3
7f0: f800283a ret
000007f4 <_exit>:
__asm__ volatile ("break 2" : : "D02"(r2), "D03"(r3) ALT_GMON_DATA );
#else
__asm__ volatile ("wrctl ctl6, %0" : : "r"(1), "D02"(r2) );
7f4: 00c00044 movi r3,1
7f8: 2005883a mov r2,r4
7fc: 180171ba wrctl ctl6,r3
800: 003fff06 br 800 <_exit+0xc>
000824 76696e55 69737265 6f207974 61442066 >University of Da< 000834 6e6f7479 00000000 00000015 00000025 >yton........%...< 000844 00000012 0000000e 0000002a 0000000b >........*.......< 000854 00000013 00000000 00000000 00000804 >................< 000864 00000000 00000000 00000100 0000017c >............|...< 000874 00000000 00000000 00000000 00008830 >............0...< 000884 000008b4 00000000 00000000 000008b4 >................< 000894 00000000 00000000 000008b4 00000000 >................< 0008a4 00000000 00000000 00000000 00000000 >................< 0008b4 00000940 00000940 00000818 00000000 >@...@...........< 0008c4 00000000 00000000 000001b4 00000000 >................< 0008d4 00000000 00000000 00000910 00000918 >................< 0008e4 00000920 00000000 00000000 00000000 > ...............< 0008f4 00000000 00000000 00000000 00000000 >................< 000904 00000000 00000000 00000000 00000004 >................< 000914 00000000 0001000a 00000000 0002000a >................< 000924 00000000 00000000 00000000 00000000 >................< 000934 00000000 00000000 ffffffff 000008b4 >................< 000944 000008b4 00000948 00000948 00000000 >....H...H.......< 000954 000008dc >....< 000958
Maintained by John Loomis, last updated Tue Jul 10 16:10:53 2007