URL
https://opencores.org/ocsvn/amber/amber/trunk
Subversion Repositories amber
Compare Revisions
- This comparison shows the changes necessary to convert path
/
- from Rev 30 to Rev 31
- ↔ Reverse comparison
Rev 30 → Rev 31
/amber/trunk/sw/tools/amber-ascii-mem.c
0,0 → 1,124
/*---------------------------------------------------------------- |
// // |
// amber-mem-ascii // |
// // |
// This file is part of the Amber project // |
// http://www.opencores.org/project,amber // |
// // |
// Description // |
// Take a string of ascii and converts it to mem // |
// // |
// Author(s): // |
// - Conor Santifort, csantifort.amber@gmail.com // |
// // |
////////////////////////////////////////////////////////////////// |
// // |
// Copyright (C) 2010 Authors and OPENCORES.ORG // |
// // |
// This source file may be used and distributed without // |
// restriction provided that this copyright statement is not // |
// removed from the file and that any derivative work contains // |
// the original copyright notice and the associated disclaimer. // |
// // |
// This source file is free software; you can redistribute it // |
// and/or modify it under the terms of the GNU Lesser General // |
// Public License as published by the Free Software Foundation; // |
// either version 2.1 of the License, or (at your option) any // |
// later version. // |
// // |
// This source is distributed in the hope that it will be // |
// useful, but WITHOUT ANY WARRANTY; without even the implied // |
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // |
// PURPOSE. See the GNU Lesser General Public License for more // |
// details. // |
// // |
// You should have received a copy of the GNU Lesser General // |
// Public License along with this source; if not, download it // |
// from http://www.opencores.org/lgpl.shtml // |
// // |
----------------------------------------------------------------*/ |
|
|
#include <stdio.h> |
#include <stdlib.h> |
|
int conv_hstring ( char *string, unsigned int * addr) |
{ |
int pos = 0; |
*addr = 0; |
|
while (((string[pos] >= '0' && string[pos] <= '9') || |
(string[pos] >= 'a' && string[pos] <= 'f')) && pos < 9) { |
if (string[pos] >= '0' && string[pos] <= '9') |
*addr = (*addr << 4) + ( string[pos++] - '0' ); |
else |
*addr = (*addr << 4) + ( string[pos++] - 'a' ) + 10; |
} |
|
return pos; |
} |
|
|
int main (int argc, char **argv) |
{ |
FILE *input_file; |
int i; |
int bytes_read; |
size_t nbytes = 100; |
char *line_buffer; |
|
char s_number[12]; |
unsigned int number; |
|
input_file = stdin; |
|
/* Get the mem starting address */ |
if ( !conv_hstring(argv[1], &number) ) |
{ |
fprintf(stderr,"ERROR: conv_hstring error in jumps file, number, with i = %d\n", i); |
return 1; |
} |
|
if (input_file==NULL) |
{ |
printf("Input file open failed\n"); |
return 1; |
} |
|
|
/* Read the input file into a structure */ |
/* reads a line */ |
line_buffer = (char *) malloc (nbytes + 1); |
|
i = 0; |
if (bytes_read = getline (&line_buffer, &nbytes, input_file)) |
{ |
while (bytes_read-1 > i) { |
printf("@%08x ", number+i); |
|
if (bytes_read-2 == i) |
printf("000000%02x\n", |
line_buffer[i]); |
if (bytes_read-3 == i) |
printf("0000%02x%02x\n", |
line_buffer[i+1], line_buffer[i]); |
if (bytes_read-4 == i) |
printf("00%02x%02x%02x\n", |
line_buffer[i+2], line_buffer[i+1], line_buffer[i]); |
if (bytes_read-5 == i){ |
printf("%02x%02x%02x%02x\n", |
line_buffer[i+3], line_buffer[i+2], line_buffer[i+1], line_buffer[i]); |
printf("@%08x 00000000\n", |
number+i+4, line_buffer[i+3], line_buffer[i+2], line_buffer[i+1], line_buffer[i]); |
} |
if (bytes_read-5 > i) |
printf("%02x%02x%02x%02x\n", |
line_buffer[i+3], line_buffer[i+2], line_buffer[i+1], line_buffer[i]); |
i+=4; |
} |
} |
|
fclose(input_file); |
} |
|
|
/amber/trunk/sw/tools/Makefile
41,7 → 41,7
|
CC = gcc |
|
all : amber-elfsplitter amber-func-jumps amber-bin2mem amber-mem-ascii |
all : amber-elfsplitter amber-func-jumps amber-bin2mem amber-mem-ascii amber-ascii-mem |
|
amber-elfsplitter : amber-elfsplitter.c |
$(CC) amber-elfsplitter.c -o amber-elfsplitter |
amber/trunk/sw/tools
Property changes :
Modified: svn:ignore
## -2,3 +2,4 ##
amber-mem-ascii
amber-func-jumps
amber-bin2mem
+amber-ascii-mem
Index: amber/trunk/sw/include/amber_registers.h
===================================================================
--- amber/trunk/sw/include/amber_registers.h (revision 30)
+++ amber/trunk/sw/include/amber_registers.h (revision 31)
@@ -49,6 +49,8 @@
#define ADR_AMBER_TEST_UART_TXD 0xf0000018
#define ADR_AMBER_TEST_SIM_CTRL 0xf000001c
#define ADR_AMBER_TEST_MEM_CTRL 0xf0000020
+#define ADR_AMBER_TEST_CYCLES 0xf0000024
+
/* Allow access to the random register over
a 16-word address range to load a series
of random numbers using lmd instruction. */
Index: amber/trunk/sw/include/common.mk
===================================================================
--- amber/trunk/sw/include/common.mk (revision 30)
+++ amber/trunk/sw/include/common.mk (revision 31)
@@ -79,7 +79,7 @@
OPTIMIZE = -Os
else
# optimize for speed
- OPTIMIZE = -O2
+ OPTIMIZE = -O3
endif
MAP = $(addsuffix .map, $(basename $(TGT)))
@@ -109,10 +109,10 @@
$(OBJ): $(DEP)
mini-libc:
- $(MAKE) -s -C ../mini-libc
+ $(MAKE) -s -C ../mini-libc MIN_SIZE=1
$(ELF):
- $(MAKE) -C $(TOOLSPATH)
+ $(MAKE) -s -C $(TOOLSPATH)
$(DIS): $(TGT)
$(DS) $(DSFLAGS) $^ > $@
/amber/trunk/sw/mini-libc/libc_asm.S
107,6 → 107,8
@ Divide r0 by r1 |
@ Answer returned in r1 |
.globl _div |
.globl __aeabi_idiv |
__aeabi_idiv: |
_div: |
stmdb sp!, {r4, lr} |
|
175,19 → 177,285
3: ldmia sp!, {r4, pc}^ |
|
|
/* strcpy: String copy function */ |
/* strcpy: String copy function |
char * strcpy ( char * destination, const char * source ); |
destination is returned |
*/ |
@ r0 points to destination |
@ r1 points to source string which terminates with a 0 |
.globl strcpy |
strcpy: |
strcpy: |
stmdb sp!, {r4-r7, lr} |
mov r6, r0 |
@ get relative alignment of strings |
and r2, r6, #3 |
and r3, r1, #3 |
@ only if both strings are zero-aligned use the fast 'aligned' algorithm |
orrs r2, r3 |
bne strcpy_slow |
|
strcpy_fast: |
@ process strings 12 bytes at a time |
ldmia r1!, {r2-r5} |
|
@ check for a zero byte |
@ only need to examine one of the strings because |
@ they are equal up to this point! |
ands r7, r2, #0xff |
andnes r7, r2, #0xff00 |
andnes r7, r2, #0xff0000 |
andnes r7, r2, #0xff000000 |
strne r2, [r6], #4 |
subeq r1, r1, #4 |
|
andnes r7, r3, #0xff |
andnes r7, r3, #0xff00 |
andnes r7, r3, #0xff0000 |
andnes r7, r3, #0xff000000 |
strne r3, [r6], #4 |
subeq r1, r1, #4 |
|
andnes r7, r4, #0xff |
andnes r7, r4, #0xff00 |
andnes r7, r4, #0xff0000 |
andnes r7, r4, #0xff000000 |
strne r4, [r6], #4 |
subeq r1, r1, #4 |
|
andnes r7, r5, #0xff |
andnes r7, r5, #0xff00 |
andnes r7, r5, #0xff0000 |
andnes r7, r5, #0xff000000 |
strne r5, [r6], #4 |
subeq r1, r1, #4 |
|
@ loop back to look at next 12 bytes |
bne strcpy_fast |
|
@ the source string contains a zero character |
|
strcpy_slow: |
@ unroll the loop 4 times |
ldrb r3, [r1], #1 |
strb r3, [r6], #1 |
cmp r3, #0 |
beq 1f |
strb r3, [r0], #1 |
b strcpy |
1: moveqs pc, lr |
ldmeqia sp!, {r4-r7, pc}^ |
|
ldrb r3, [r1], #1 |
strb r3, [r6], #1 |
cmp r3, #0 |
ldmeqia sp!, {r4-r7, pc}^ |
|
ldrb r3, [r1], #1 |
strb r3, [r6], #1 |
cmp r3, #0 |
ldmeqia sp!, {r4-r7, pc}^ |
|
ldrb r3, [r1], #1 |
strb r3, [r6], #1 |
cmp r3, #0 |
ldmeqia sp!, {r4-r7, pc}^ |
|
b strcpy_slow |
|
|
/* int strcmp ( const char * str1, const char * str2 ); |
A value greater than zero indicates that the first character |
that does not match has a greater value in str1 than in str2; |
And a value less than zero indicates the opposite. |
*/ |
.globl strcmp |
strcmp: |
stmdb sp!, {r4-r8, lr} |
|
@ only if both strings are zero-aligned use the fast 'aligned' algorithm |
orr r2, r0, r1 |
ands r2, r2, #3 |
bne strcmp_slow |
|
strcmp_fast: |
@ process strings 12 bytes at a time |
ldmia r0!, {r2-r4} |
ldmia r1!, {r5-r7} |
cmp r2, r5 |
bne 1f |
cmpeq r3, r6 |
bne 2f |
cmpeq r4, r7 |
bne 3f |
|
@ strings are equal - find a zero byte |
@ only need to examine one of the strings because |
@ they are equal up to this point! |
ands r8, r2, #0xff |
andnes r8, r2, #0xff00 |
andnes r8, r2, #0xff0000 |
andnes r8, r2, #0xff000000 |
|
andnes r8, r3, #0xff |
andnes r8, r3, #0xff00 |
andnes r8, r3, #0xff0000 |
andnes r8, r3, #0xff000000 |
|
andnes r8, r4, #0xff |
andnes r8, r4, #0xff00 |
andnes r8, r4, #0xff0000 |
andnes r8, r4, #0xff000000 |
|
@ loop back to look at next 12 bytes |
bne strcmp_fast |
|
@ the first string contains a zero character |
@ the strings are the same, so both strings end |
moveq r0, #0 |
ldmeqia sp!, {r4-r8, pc}^ |
|
|
@ Roll back the string pointers to before the mismatch |
@ then handle the remaining part byte by byte |
1: sub r0, r0, #12 |
sub r1, r1, #12 |
|
strcmp_slow: |
ldrb r2, [r0], #1 |
ldrb r3, [r1], #1 |
eors r4, r2, r3 @ are the bytes equal ? |
bne bytes_different |
ldrb r5, [r0], #1 |
ldrb r6, [r1], #1 |
cmp r2, #0 @ are they equal and zero ? |
beq bytes_zero |
eors r7, r5, r6 @ are the bytes equal ? |
bne bytes_different |
ldrb r2, [r0], #1 |
ldrb r3, [r1], #1 |
cmp r5, #0 @ are they equal and zero ? |
beq bytes_zero |
eors r4, r2, r3 @ are the bytes equal ? |
bne bytes_different |
ldrb r5, [r0], #1 |
ldrb r6, [r1], #1 |
cmp r2, #0 @ are they equal and zero ? |
beq bytes_zero |
eors r7, r5, r6 @ are the bytes equal ? |
bne bytes_different |
cmp r5, #0 @ are they equal and zero ? |
beq bytes_zero |
|
bne strcmp_slow |
|
|
|
@ Skipping first 4 bytes so just check they |
@ don't contain an end of string 0 character |
2: ands r8, r2, #0xff |
andnes r8, r2, #0xff00 |
andnes r8, r2, #0xff0000 |
andnes r8, r2, #0xff000000 |
beq bytes_zero |
|
@ start looking at 5th byte |
sub r0, r0, #8 |
sub r1, r1, #8 |
|
ldrb r2, [r0], #1 |
ldrb r3, [r1], #1 |
eors r4, r2, r3 @ are the bytes equal ? |
bne bytes_different |
ldrb r5, [r0], #1 |
ldrb r6, [r1], #1 |
cmp r2, #0 @ are they equal and zero ? |
beq bytes_zero |
eors r7, r5, r6 @ are the bytes equal ? |
bne bytes_different |
ldrb r2, [r0], #1 |
ldrb r3, [r1], #1 |
cmp r5, #0 @ are they equal and zero ? |
beq bytes_zero |
eors r4, r2, r3 @ are the bytes equal ? |
bne bytes_different |
ldrb r5, [r0], #1 |
ldrb r6, [r1], #1 |
cmp r2, #0 @ are they equal and zero ? |
beq bytes_zero |
eors r7, r5, r6 @ are the bytes equal ? |
bne bytes_different |
cmp r5, #0 @ are they equal and zero ? |
beq bytes_zero |
|
bne strcmp_slow |
|
@ Skipping first 8 bytes so just check they |
@ don't contain an end of string 0 character |
3: ands r8, r2, #0xff |
andnes r8, r2, #0xff00 |
andnes r8, r2, #0xff0000 |
andnes r8, r2, #0xff000000 |
|
andnes r8, r3, #0xff |
andnes r8, r3, #0xff00 |
andnes r8, r3, #0xff0000 |
andnes r8, r3, #0xff000000 |
beq bytes_zero |
|
sub r0, r0, #4 |
sub r1, r1, #4 |
ldrb r2, [r0], #1 |
ldrb r3, [r1], #1 |
eors r4, r2, r3 @ are the bytes equal ? |
bne bytes_different |
ldrb r5, [r0], #1 |
ldrb r6, [r1], #1 |
cmp r2, #0 @ are they equal and zero ? |
beq bytes_zero |
eors r7, r5, r6 @ are the bytes equal ? |
bne bytes_different |
ldrb r2, [r0], #1 |
ldrb r3, [r1], #1 |
cmp r5, #0 @ are they equal and zero ? |
beq bytes_zero |
eors r4, r2, r3 @ are the bytes equal ? |
bne bytes_different |
ldrb r5, [r0], #1 |
ldrb r6, [r1], #1 |
cmp r2, #0 @ are they equal and zero ? |
beq bytes_zero |
eors r7, r5, r6 @ are the bytes equal ? |
bne bytes_different |
cmp r5, #0 @ are they equal and zero ? |
beq bytes_zero |
|
bne strcmp_slow |
|
|
bytes_zero: |
moveq r0, #0 @ if equal and zero, return zero |
ldmeqia sp!, {r4-r8, pc}^ |
|
|
bytes_different: |
sub r0, r5, r6 |
ldmia sp!, {r4-r8, pc}^ |
|
|
|
/* void *malloc(size_t size); */ |
.globl malloc |
malloc: |
ldr r1, AdrMalloc |
ldr r0, [r1] |
add r0, r0, #0x10000 |
str r0, [r1] |
mov pc, lr |
|
|
.globl times |
times: |
@ TODO |
mov r0, #0 |
mov pc, lr |
|
|
/* strncpy: String copy function */ |
@ r0 points to destination |
@ r1 points to source string |
236,6 → 504,7
2: ldmia sp!, {r4, r5, r6, pc}^ |
|
|
AdrMalloc: .word 0x7000000 |
AdrTestStatus: .word ADR_AMBER_TEST_STATUS |
AdrUARTDR: .word ADR_AMBER_UART0_DR |
AdrUARTFR: .word ADR_AMBER_UART0_FR |
/amber/trunk/sw/mini-libc/Makefile
47,8 → 47,11
|
OBJ = $(addsuffix .o, $(basename $(SRC))) |
CC = $(AMBER_CROSSTOOL)-gcc |
|
# optimize for size |
OPTIMIZE = -Os |
|
CFLAGS = -c -march=armv2a -mno-thumb-interwork -O -ffreestanding -I../include |
CFLAGS = -c -march=armv2a -mno-thumb-interwork $(OPTIMIZE) -ffreestanding -I../include |
ASFLAGS = -I../include |
|
$(TGT): $(OBJ) |
/amber/trunk/sw/dhry/dhry.c
0,0 → 1,370
/* |
**************************************************************************** |
* |
* "DHRYSTONE" Benchmark Program |
* ----------------------------- |
* |
* Version: C, Version 2.1 |
* |
* File: dhry_1.c (part 2 of 3) |
* |
* Date: May 25, 1988 |
* |
* Author: Reinhold P. Weicker |
* |
**************************************************************************** |
*/ |
|
/* Note that the stdio.h referred to here is the one in |
mini-libc. This applications compiles in mini-libc |
so it can run stand-alone. |
*/ |
#include "stdio.h" |
|
#include "dhry.h" |
#include <stdio.h> |
#include <stdlib.h> |
#include <string.h> |
#include "amber_registers.h" |
|
#define RUNS 256 |
|
/* Global Variables: */ |
|
Rec_Pointer Ptr_Glob, |
Next_Ptr_Glob; |
int Int_Glob; |
Boolean Bool_Glob; |
char Ch_1_Glob, |
Ch_2_Glob; |
int Arr_1_Glob [50]; |
int Arr_2_Glob [50] [50]; |
|
|
Enumeration Func_1 (); |
/* forward declaration necessary since Enumeration may not simply be int */ |
|
#ifndef REG |
Boolean Reg = false; |
#define REG |
/* REG becomes defined as empty */ |
/* i.e. no register variables */ |
#else |
Boolean Reg = true; |
#endif |
|
/* variables for time measurement: */ |
#define Too_Small_Time 10000 |
|
long Begin_Time, |
End_Time, |
User_Time; |
float Microseconds, |
Dhrystones_Per_Second; |
|
/* end of variables for time measurement */ |
|
|
main () |
/*****/ |
|
/* main program, corresponds to procedures */ |
/* Main and Proc_0 in the Ada version */ |
{ |
One_Fifty Int_1_Loc; |
REG One_Fifty Int_2_Loc; |
One_Fifty Int_3_Loc; |
REG char Ch_Index; |
Enumeration Enum_Loc; |
Str_30 Str_1_Loc; |
Str_30 Str_2_Loc; |
REG int Run_Index; |
REG int Number_Of_Runs; |
|
/* Initializations */ |
|
Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type)); |
Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type)); |
|
Ptr_Glob->Ptr_Comp = Next_Ptr_Glob; |
Ptr_Glob->Discr = Ident_1; |
Ptr_Glob->variant.var_1.Enum_Comp = Ident_3; |
|
Ptr_Glob->variant.var_1.Int_Comp = 40; |
strcpy (Ptr_Glob->variant.var_1.Str_Comp, |
"DHRYSTONE PROGRAM, SOME STRING"); |
strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING"); |
|
Arr_2_Glob [8][7] = 10; |
/* Was missing in published program. Without this statement, */ |
/* Arr_2_Glob [8][7] would have an undefined value. */ |
/* Warning: With 16-Bit processors and Number_Of_Runs > 32000, */ |
/* overflow may occur for this array element. */ |
|
printf ("\n"); |
printf ("Dhrystone Benchmark, Version 2.1 (Language: C)\n"); |
printf ("\n"); |
if (Reg) |
{ |
printf ("Program compiled with 'register' attribute\n"); |
printf ("\n"); |
} |
else |
{ |
printf ("Program compiled without 'register' attribute\n"); |
printf ("\n"); |
} |
|
Number_Of_Runs = RUNS; |
printf ("Execution starts, %d runs through Dhrystone\n", Number_Of_Runs); |
|
/***************/ |
/* Start timer */ |
/***************/ |
|
Begin_Time = * (volatile unsigned int *) ADR_AMBER_TEST_CYCLES; |
|
|
for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index) |
{ |
|
Proc_5(); |
Proc_4(); |
/* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */ |
Int_1_Loc = 2; |
Int_2_Loc = 3; |
strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING"); |
Enum_Loc = Ident_2; |
Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc); |
/* Bool_Glob == 1 */ |
while (Int_1_Loc < Int_2_Loc) /* loop body executed once */ |
{ |
Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc; |
/* Int_3_Loc == 7 */ |
Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc); |
/* Int_3_Loc == 7 */ |
Int_1_Loc += 1; |
} /* while */ |
/* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */ |
Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc); |
/* Int_Glob == 5 */ |
Proc_1 (Ptr_Glob); |
for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index) |
/* loop body executed twice */ |
{ |
if (Enum_Loc == Func_1 (Ch_Index, 'C')) |
/* then, not executed */ |
{ |
Proc_6 (Ident_1, &Enum_Loc); |
strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING"); |
Int_2_Loc = Run_Index; |
Int_Glob = Run_Index; |
} |
} |
/* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */ |
Int_2_Loc = Int_2_Loc * Int_1_Loc; |
Int_1_Loc = Int_2_Loc / Int_3_Loc; |
Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc; |
/* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */ |
Proc_2 (&Int_1_Loc); |
/* Int_1_Loc == 5 */ |
|
} /* loop "for Run_Index" */ |
|
/**************/ |
/* Stop timer */ |
/**************/ |
End_Time = * (volatile unsigned int *) ADR_AMBER_TEST_CYCLES; |
|
printf ("Execution ends\n"); |
printf ("\n"); |
|
printf ("Final values of the variables used in the benchmark:\n"); |
printf ("\n"); |
printf ("Int_Glob: %d\n", Int_Glob); |
printf (" should be: %d\n", 5); |
printf ("Bool_Glob: %d\n", Bool_Glob); |
printf (" should be: %d\n", 1); |
printf ("Ch_1_Glob: %c\n", Ch_1_Glob); |
printf (" should be: %c\n", 'A'); |
printf ("Ch_2_Glob: %c\n", Ch_2_Glob); |
printf (" should be: %c\n", 'B'); |
printf ("Arr_1_Glob[8]: %d\n", Arr_1_Glob[8]); |
printf (" should be: %d\n", 7); |
printf ("Arr_2_Glob[8][7]: %d\n", Arr_2_Glob[8][7]); |
printf (" should be: %d\n", Number_Of_Runs+10); |
printf ("Ptr_Glob->\n"); |
printf (" Ptr_Comp: 0x%08x\n", (int) Ptr_Glob->Ptr_Comp); |
printf (" should be: (implementation-dependent)\n"); |
printf (" Discr: %d\n", Ptr_Glob->Discr); |
printf (" should be: %d\n", 0); |
printf (" Enum_Comp: %d\n", Ptr_Glob->variant.var_1.Enum_Comp); |
printf (" should be: %d\n", 2); |
printf (" Int_Comp: %d\n", Ptr_Glob->variant.var_1.Int_Comp); |
printf (" should be: %d\n", 17); |
printf (" Str_Comp: %s\n", Ptr_Glob->variant.var_1.Str_Comp); |
printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n"); |
printf ("Next_Ptr_Glob->\n"); |
printf (" Ptr_Comp: 0x%08x\n", (int) Next_Ptr_Glob->Ptr_Comp); |
printf (" should be: (implementation-dependent), same as above\n"); |
printf (" Discr: %d\n", Next_Ptr_Glob->Discr); |
printf (" should be: %d\n", 0); |
printf (" Enum_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Enum_Comp); |
printf (" should be: %d\n", 1); |
printf (" Int_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Int_Comp); |
printf (" should be: %d\n", 18); |
printf (" Str_Comp: %s\n", |
Next_Ptr_Glob->variant.var_1.Str_Comp); |
printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n"); |
printf ("Int_1_Loc: %d\n", Int_1_Loc); |
printf (" should be: %d\n", 5); |
printf ("Int_2_Loc: %d\n", Int_2_Loc); |
printf (" should be: %d\n", 13); |
printf ("Int_3_Loc: %d\n", Int_3_Loc); |
printf (" should be: %d\n", 7); |
printf ("Enum_Loc: %d\n", Enum_Loc); |
printf (" should be: %d\n", 1); |
printf ("Str_1_Loc: %s\n", Str_1_Loc); |
printf (" should be: DHRYSTONE PROGRAM, 1'ST STRING\n"); |
printf ("Str_2_Loc: %s\n", Str_2_Loc); |
printf (" should be: DHRYSTONE PROGRAM, 2'ND STRING\n"); |
printf ("\n"); |
|
User_Time = End_Time - Begin_Time; |
|
if (User_Time < Too_Small_Time) |
{ |
printf ("Measured time too small to obtain meaningful results\n"); |
printf ("Please increase number of runs\n"); |
printf ("\n"); |
printf (" \n"); /* flush uart */ |
} |
else |
{ |
printf ("Cycles for one run through Dhrystone -\n"); |
printf (" Vax 11/780: 569\n"); |
printf (" Intel Core i3: 389\n"); |
printf (" Me: %d \n", (End_Time - Begin_Time)/Number_Of_Runs); |
printf (" \n"); /* flush uart */ |
|
/* |
Another common representation of the Dhrystone benchmark |
is the DMIPS (Dhrystone MIPS) obtained when the Dhrystone |
score is divided by 1,757 (the number of Dhrystones per |
second obtained on the VAX 11/780, nominally a 1 MIPS machine). |
|
=> 1 dhrystone = 569 cycles on a 1 instruction per cycle Vax machine. |
*/ |
} |
|
} |
|
|
Proc_1 (Ptr_Val_Par) |
/******************/ |
|
REG Rec_Pointer Ptr_Val_Par; |
/* executed once */ |
{ |
REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp; |
/* == Ptr_Glob_Next */ |
/* Local variable, initialized with Ptr_Val_Par->Ptr_Comp, */ |
/* corresponds to "rename" in Ada, "with" in Pascal */ |
structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob); |
Ptr_Val_Par->variant.var_1.Int_Comp = 5; |
Next_Record->variant.var_1.Int_Comp |
= Ptr_Val_Par->variant.var_1.Int_Comp; |
Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp; |
Proc_3 (&Next_Record->Ptr_Comp); |
/* Ptr_Val_Par->Ptr_Comp->Ptr_Comp |
== Ptr_Glob->Ptr_Comp */ |
if (Next_Record->Discr == Ident_1) |
/* then, executed */ |
{ |
Next_Record->variant.var_1.Int_Comp = 6; |
|
Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp, |
&Next_Record->variant.var_1.Enum_Comp); |
|
Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp; |
Proc_7 (Next_Record->variant.var_1.Int_Comp, 10, |
&Next_Record->variant.var_1.Int_Comp); |
} |
else /* not executed */{ |
structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp); |
} |
} /* Proc_1 */ |
|
|
Proc_2 (Int_Par_Ref) |
/******************/ |
/* executed once */ |
/* *Int_Par_Ref == 1, becomes 4 */ |
|
One_Fifty *Int_Par_Ref; |
{ |
One_Fifty Int_Loc; |
Enumeration Enum_Loc; |
|
Int_Loc = *Int_Par_Ref + 10; |
do /* executed once */ |
if (Ch_1_Glob == 'A') |
/* then, executed */ |
{ |
Int_Loc -= 1; |
*Int_Par_Ref = Int_Loc - Int_Glob; |
Enum_Loc = Ident_1; |
} /* if */ |
while (Enum_Loc != Ident_1); /* true */ |
} /* Proc_2 */ |
|
|
Proc_3 (Ptr_Ref_Par) |
/******************/ |
/* executed once */ |
/* Ptr_Ref_Par becomes Ptr_Glob */ |
|
Rec_Pointer *Ptr_Ref_Par; |
|
{ |
if (Ptr_Glob != Null) |
/* then, executed */ |
*Ptr_Ref_Par = Ptr_Glob->Ptr_Comp; |
Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp); |
} /* Proc_3 */ |
|
|
Proc_4 () /* without parameters */ |
/*******/ |
/* executed once */ |
{ |
Boolean Bool_Loc; |
|
Bool_Loc = Ch_1_Glob == 'A'; |
Bool_Glob = Bool_Loc | Bool_Glob; |
Ch_2_Glob = 'B'; |
} /* Proc_4 */ |
|
|
Proc_5 () /* without parameters */ |
/*******/ |
/* executed once */ |
{ |
Ch_1_Glob = 'A'; |
Bool_Glob = false; |
} /* Proc_5 */ |
|
|
/* Procedure for the assignment of structures, */ |
/* if the C compiler doesn't support this feature */ |
#ifdef NOSTRUCTASSIGN |
memcpy (d, s, l) |
register char *d; |
register char *s; |
register int l; |
{ |
while (l--) *d++ = *s++; |
} |
#endif |
|
|
/amber/trunk/sw/dhry/dhry_2.c
0,0 → 1,199
/* |
**************************************************************************** |
* |
* "DHRYSTONE" Benchmark Program |
* ----------------------------- |
* |
* Version: C, Version 2.1 |
* |
* File: dhry_2.c (part 3 of 3) |
* |
* Date: May 25, 1988 |
* |
* Author: Reinhold P. Weicker |
* |
**************************************************************************** |
*/ |
|
/* Note that the stdio.h referred to here is the one in |
mini-libc. This applications compiles in mini-libc |
so it can run stand-alone. |
*/ |
#include "stdio.h" |
#include "dhry.h" |
//#include <stdio.h> |
//#include <stdlib.h> |
|
#ifndef REG |
#define REG |
/* REG becomes defined as empty */ |
/* i.e. no register variables */ |
#endif |
|
extern int Int_Glob; |
extern char Ch_1_Glob; |
|
|
Proc_6 (Enum_Val_Par, Enum_Ref_Par) |
/*********************************/ |
/* executed once */ |
/* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */ |
|
Enumeration Enum_Val_Par; |
Enumeration *Enum_Ref_Par; |
{ |
*Enum_Ref_Par = Enum_Val_Par; |
if (! Func_3 (Enum_Val_Par)) |
/* then, not executed */ |
*Enum_Ref_Par = Ident_4; |
switch (Enum_Val_Par) |
{ |
case Ident_1: |
*Enum_Ref_Par = Ident_1; |
break; |
case Ident_2: |
if (Int_Glob > 100) |
/* then */ |
*Enum_Ref_Par = Ident_1; |
else *Enum_Ref_Par = Ident_4; |
break; |
case Ident_3: /* executed */ |
*Enum_Ref_Par = Ident_2; |
break; |
case Ident_4: break; |
case Ident_5: |
*Enum_Ref_Par = Ident_3; |
break; |
} /* switch */ |
} /* Proc_6 */ |
|
|
Proc_7 (Int_1_Par_Val, Int_2_Par_Val, Int_Par_Ref) |
/**********************************************/ |
/* executed three times */ |
/* first call: Int_1_Par_Val == 2, Int_2_Par_Val == 3, */ |
/* Int_Par_Ref becomes 7 */ |
/* second call: Int_1_Par_Val == 10, Int_2_Par_Val == 5, */ |
/* Int_Par_Ref becomes 17 */ |
/* third call: Int_1_Par_Val == 6, Int_2_Par_Val == 10, */ |
/* Int_Par_Ref becomes 18 */ |
One_Fifty Int_1_Par_Val; |
One_Fifty Int_2_Par_Val; |
One_Fifty *Int_Par_Ref; |
{ |
One_Fifty Int_Loc; |
|
Int_Loc = Int_1_Par_Val + 2; |
*Int_Par_Ref = Int_2_Par_Val + Int_Loc; |
} /* Proc_7 */ |
|
|
Proc_8 (Arr_1_Par_Ref, Arr_2_Par_Ref, Int_1_Par_Val, Int_2_Par_Val) |
/*********************************************************************/ |
/* executed once */ |
/* Int_Par_Val_1 == 3 */ |
/* Int_Par_Val_2 == 7 */ |
Arr_1_Dim Arr_1_Par_Ref; |
Arr_2_Dim Arr_2_Par_Ref; |
int Int_1_Par_Val; |
int Int_2_Par_Val; |
{ |
REG One_Fifty Int_Index; |
REG One_Fifty Int_Loc; |
|
Int_Loc = Int_1_Par_Val + 5; |
Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val; |
Arr_1_Par_Ref [Int_Loc+1] = Arr_1_Par_Ref [Int_Loc]; |
Arr_1_Par_Ref [Int_Loc+30] = Int_Loc; |
for (Int_Index = Int_Loc; Int_Index <= Int_Loc+1; ++Int_Index) |
Arr_2_Par_Ref [Int_Loc] [Int_Index] = Int_Loc; |
Arr_2_Par_Ref [Int_Loc] [Int_Loc-1] += 1; |
Arr_2_Par_Ref [Int_Loc+20] [Int_Loc] = Arr_1_Par_Ref [Int_Loc]; |
Int_Glob = 5; |
} /* Proc_8 */ |
|
|
Enumeration Func_1 (Ch_1_Par_Val, Ch_2_Par_Val) |
/*************************************************/ |
/* executed three times */ |
/* first call: Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R' */ |
/* second call: Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C' */ |
/* third call: Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C' */ |
|
Capital_Letter Ch_1_Par_Val; |
Capital_Letter Ch_2_Par_Val; |
{ |
Capital_Letter Ch_1_Loc; |
Capital_Letter Ch_2_Loc; |
|
Ch_1_Loc = Ch_1_Par_Val; |
Ch_2_Loc = Ch_1_Loc; |
if (Ch_2_Loc != Ch_2_Par_Val) |
/* then, executed */ |
return (Ident_1); |
else /* not executed */ |
{ |
Ch_1_Glob = Ch_1_Loc; |
return (Ident_2); |
} |
} /* Func_1 */ |
|
|
Boolean Func_2 (Str_1_Par_Ref, Str_2_Par_Ref) |
/*************************************************/ |
/* executed once */ |
/* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */ |
/* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */ |
|
Str_30 Str_1_Par_Ref; |
Str_30 Str_2_Par_Ref; |
{ |
REG One_Thirty Int_Loc; |
Capital_Letter Ch_Loc; |
|
Int_Loc = 2; |
while (Int_Loc <= 2) /* loop body executed once */ |
if (Func_1 (Str_1_Par_Ref[Int_Loc], |
Str_2_Par_Ref[Int_Loc+1]) == Ident_1) |
/* then, executed */ |
{ |
Ch_Loc = 'A'; |
Int_Loc += 1; |
} /* if, while */ |
if (Ch_Loc >= 'W' && Ch_Loc < 'Z') |
/* then, not executed */ |
Int_Loc = 7; |
if (Ch_Loc == 'R') |
/* then, not executed */ |
return (true); |
else /* executed */ |
{ |
if (strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0) |
/* then, not executed */ |
{ |
Int_Loc += 7; |
Int_Glob = Int_Loc; |
return (true); |
} |
else /* executed */ |
return (false); |
} /* if Ch_Loc */ |
} /* Func_2 */ |
|
|
Boolean Func_3 (Enum_Par_Val) |
/***************************/ |
/* executed once */ |
/* Enum_Par_Val == Ident_3 */ |
Enumeration Enum_Par_Val; |
{ |
Enumeration Enum_Loc; |
|
Enum_Loc = Enum_Par_Val; |
if (Enum_Loc == Ident_3) |
/* then, executed */ |
return (true); |
else /* not executed */ |
return (false); |
} /* Func_3 */ |
|
/amber/trunk/sw/dhry/sections.lds
0,0 → 1,83
/*---------------------------------------------------------------- |
// // |
// sections.lds // |
// // |
// This file is part of the Amber project // |
// http://www.opencores.org/project,amber // |
// // |
// Description // |
// Sections linker file for the hello-world application. // |
// Note that the address map starts at 0x0 because this is // |
// a stand-alone application, not using the boot-loader. // |
// As such, it would need to be put into the FPGA during // |
// synthesis. // |
// // |
// Author(s): // |
// - Conor Santifort, csantifort.amber@gmail.com // |
// // |
////////////////////////////////////////////////////////////////// |
// // |
// Copyright (C) 2010 Authors and OPENCORES.ORG // |
// // |
// This source file may be used and distributed without // |
// restriction provided that this copyright statement is not // |
// removed from the file and that any derivative work contains // |
// the original copyright notice and the associated disclaimer. // |
// // |
// This source file is free software; you can redistribute it // |
// and/or modify it under the terms of the GNU Lesser General // |
// Public License as published by the Free Software Foundation; // |
// either version 2.1 of the License, or (at your option) any // |
// later version. // |
// // |
// This source is distributed in the hope that it will be // |
// useful, but WITHOUT ANY WARRANTY; without even the implied // |
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // |
// PURPOSE. See the GNU Lesser General Public License for more // |
// details. // |
// // |
// You should have received a copy of the GNU Lesser General // |
// Public License along with this source; if not, download it // |
// from http://www.opencores.org/lgpl.shtml // |
// // |
----------------------------------------------------------------*/ |
|
|
ENTRY(main) |
|
|
SECTIONS { |
|
. = 0x00080000; |
|
._start : |
{ |
start*(.text) |
} |
|
.text : |
{ |
*(.text) |
} |
|
.rodata : |
{ |
*(.rodata) |
} |
|
.data : |
{ |
*(.data) |
} |
|
.bss : |
{ |
*(.bss) |
} |
|
.stack : |
{ |
__stack = . ; |
} |
|
} |
/amber/trunk/sw/dhry/dhry.h
0,0 → 1,408
/* |
**************************************************************************** |
* |
* "DHRYSTONE" Benchmark Program |
* ----------------------------- |
* |
* Version: C, Version 2.1 |
* |
* File: dhry.h (part 1 of 3) |
* |
* Date: May 25, 1988 |
* |
* Author: Reinhold P. Weicker |
* Siemens AG, AUT E 51 |
* Postfach 3220 |
* 8520 Erlangen |
* Germany (West) |
* Phone: [+49]-9131-7-20330 |
* (8-17 Central European Time) |
* Usenet: ..!mcsun!unido!estevax!weicker |
* |
* Original Version (in Ada) published in |
* "Communications of the ACM" vol. 27., no. 10 (Oct. 1984), |
* pp. 1013 - 1030, together with the statistics |
* on which the distribution of statements etc. is based. |
* |
* In this C version, the following C library functions are used: |
* - strcpy, strcmp (inside the measurement loop) |
* - printf, scanf (outside the measurement loop) |
* In addition, Berkeley UNIX system calls "times ()" or "time ()" |
* are used for execution time measurement. For measurements |
* on other systems, these calls have to be changed. |
* |
* Collection of Results: |
* Reinhold Weicker (address see above) and |
* |
* Rick Richardson |
* PC Research. Inc. |
* 94 Apple Orchard Drive |
* Tinton Falls, NJ 07724 |
* Phone: (201) 389-8963 (9-17 EST) |
* Usenet: ...!uunet!pcrat!rick |
* |
* Please send results to Rick Richardson and/or Reinhold Weicker. |
* Complete information should be given on hardware and software used. |
* Hardware information includes: Machine type, CPU, type and size |
* of caches; for microprocessors: clock frequency, memory speed |
* (number of wait states). |
* Software information includes: Compiler (and runtime library) |
* manufacturer and version, compilation switches, OS version. |
* The Operating System version may give an indication about the |
* compiler; Dhrystone itself performs no OS calls in the measurement loop. |
* |
* The complete output generated by the program should be mailed |
* such that at least some checks for correctness can be made. |
* |
*************************************************************************** |
* |
* History: This version C/2.1 has been made for two reasons: |
* |
* 1) There is an obvious need for a common C version of |
* Dhrystone, since C is at present the most popular system |
* programming language for the class of processors |
* (microcomputers, minicomputers) where Dhrystone is used most. |
* There should be, as far as possible, only one C version of |
* Dhrystone such that results can be compared without |
* restrictions. In the past, the C versions distributed |
* by Rick Richardson (Version 1.1) and by Reinhold Weicker |
* had small (though not significant) differences. |
* |
* 2) As far as it is possible without changes to the Dhrystone |
* statistics, optimizing compilers should be prevented from |
* removing significant statements. |
* |
* This C version has been developed in cooperation with |
* Rick Richardson (Tinton Falls, NJ), it incorporates many |
* ideas from the "Version 1.1" distributed previously by |
* him over the UNIX network Usenet. |
* I also thank Chaim Benedelac (National Semiconductor), |
* David Ditzel (SUN), Earl Killian and John Mashey (MIPS), |
* Alan Smith and Rafael Saavedra-Barrera (UC at Berkeley) |
* for their help with comments on earlier versions of the |
* benchmark. |
* |
* Changes: In the initialization part, this version follows mostly |
* Rick Richardson's version distributed via Usenet, not the |
* version distributed earlier via floppy disk by Reinhold Weicker. |
* As a concession to older compilers, names have been made |
* unique within the first 8 characters. |
* Inside the measurement loop, this version follows the |
* version previously distributed by Reinhold Weicker. |
* |
* At several places in the benchmark, code has been added, |
* but within the measurement loop only in branches that |
* are not executed. The intention is that optimizing compilers |
* should be prevented from moving code out of the measurement |
* loop, or from removing code altogether. Since the statements |
* that are executed within the measurement loop have NOT been |
* changed, the numbers defining the "Dhrystone distribution" |
* (distribution of statements, operand types and locality) |
* still hold. Except for sophisticated optimizing compilers, |
* execution times for this version should be the same as |
* for previous versions. |
* |
* Since it has proven difficult to subtract the time for the |
* measurement loop overhead in a correct way, the loop check |
* has been made a part of the benchmark. This does have |
* an impact - though a very minor one - on the distribution |
* statistics which have been updated for this version. |
* |
* All changes within the measurement loop are described |
* and discussed in the companion paper "Rationale for |
* Dhrystone version 2". |
* |
* Because of the self-imposed limitation that the order and |
* distribution of the executed statements should not be |
* changed, there are still cases where optimizing compilers |
* may not generate code for some statements. To a certain |
* degree, this is unavoidable for small synthetic benchmarks. |
* Users of the benchmark are advised to check code listings |
* whether code is generated for all statements of Dhrystone. |
* |
* Version 2.1 is identical to version 2.0 distributed via |
* the UNIX network Usenet in March 1988 except that it corrects |
* some minor deficiencies that were found by users of version 2.0. |
* The only change within the measurement loop is that a |
* non-executed "else" part was added to the "if" statement in |
* Func_3, and a non-executed "else" part removed from Proc_3. |
* |
*************************************************************************** |
* |
* Defines: The following "Defines" are possible: |
* -DREG=register (default: Not defined) |
* As an approximation to what an average C programmer |
* might do, the "register" storage class is applied |
* (if enabled by -DREG=register) |
* - for local variables, if they are used (dynamically) |
* five or more times |
* - for parameters if they are used (dynamically) |
* six or more times |
* Note that an optimal "register" strategy is |
* compiler-dependent, and that "register" declarations |
* do not necessarily lead to faster execution. |
* -DNOSTRUCTASSIGN (default: Not defined) |
* Define if the C compiler does not support |
* assignment of structures. |
* -DNOENUM (default: Not defined) |
* Define if the C compiler does not support |
* enumeration types. |
* -DTIMES (default) |
* -DTIME |
* The "times" function of UNIX (returning process times) |
* or the "time" function (returning wallclock time) |
* is used for measurement. |
* For single user machines, "time ()" is adequate. For |
* multi-user machines where you cannot get single-user |
* access, use the "times ()" function. If you have |
* neither, use a stopwatch in the dead of night. |
* "printf"s are provided marking the points "Start Timer" |
* and "Stop Timer". DO NOT use the UNIX "time(1)" |
* command, as this will measure the total time to |
* run this program, which will (erroneously) include |
* the time to allocate storage (malloc) and to perform |
* the initialization. |
* -DHZ=nnn |
* In Berkeley UNIX, the function "times" returns process |
* time in 1/HZ seconds, with HZ = 60 for most systems. |
* CHECK YOUR SYSTEM DESCRIPTION BEFORE YOU JUST APPLY |
* A VALUE. |
* |
*************************************************************************** |
* |
* Compilation model and measurement (IMPORTANT): |
* |
* This C version of Dhrystone consists of three files: |
* - dhry.h (this file, containing global definitions and comments) |
* - dhry_1.c (containing the code corresponding to Ada package Pack_1) |
* - dhry_2.c (containing the code corresponding to Ada package Pack_2) |
* |
* The following "ground rules" apply for measurements: |
* - Separate compilation |
* - No procedure merging |
* - Otherwise, compiler optimizations are allowed but should be indicated |
* - Default results are those without register declarations |
* See the companion paper "Rationale for Dhrystone Version 2" for a more |
* detailed discussion of these ground rules. |
* |
* For 16-Bit processors (e.g. 80186, 80286), times for all compilation |
* models ("small", "medium", "large" etc.) should be given if possible, |
* together with a definition of these models for the compiler system used. |
* |
************************************************************************** |
* |
* Dhrystone (C version) statistics: |
* |
* [Comment from the first distribution, updated for version 2. |
* Note that because of language differences, the numbers are slightly |
* different from the Ada version.] |
* |
* The following program contains statements of a high level programming |
* language (here: C) in a distribution considered representative: |
* |
* assignments 52 (51.0 %) |
* control statements 33 (32.4 %) |
* procedure, function calls 17 (16.7 %) |
* |
* 103 statements are dynamically executed. The program is balanced with |
* respect to the three aspects: |
* |
* - statement type |
* - operand type |
* - operand locality |
* operand global, local, parameter, or constant. |
* |
* The combination of these three aspects is balanced only approximately. |
* |
* 1. Statement Type: |
* ----------------- number |
* |
* V1 = V2 9 |
* (incl. V1 = F(..) |
* V = Constant 12 |
* Assignment, 7 |
* with array element |
* Assignment, 6 |
* with record component |
* -- |
* 34 34 |
* |
* X = Y +|-|"&&"|"|" Z 5 |
* X = Y +|-|"==" Constant 6 |
* X = X +|- 1 3 |
* X = Y *|/ Z 2 |
* X = Expression, 1 |
* two operators |
* X = Expression, 1 |
* three operators |
* -- |
* 18 18 |
* |
* if .... 14 |
* with "else" 7 |
* without "else" 7 |
* executed 3 |
* not executed 4 |
* for ... 7 | counted every time |
* while ... 4 | the loop condition |
* do ... while 1 | is evaluated |
* switch ... 1 |
* break 1 |
* declaration with 1 |
* initialization |
* -- |
* 34 34 |
* |
* P (...) procedure call 11 |
* user procedure 10 |
* library procedure 1 |
* X = F (...) |
* function call 6 |
* user function 5 |
* library function 1 |
* -- |
* 17 17 |
* --- |
* 103 |
* |
* The average number of parameters in procedure or function calls |
* is 1.82 (not counting the function values as implicit parameters). |
* |
* |
* 2. Operators |
* ------------ |
* number approximate |
* percentage |
* |
* Arithmetic 32 50.8 |
* |
* + 21 33.3 |
* - 7 11.1 |
* * 3 4.8 |
* / (int div) 1 1.6 |
* |
* Comparison 27 42.8 |
* |
* == 9 14.3 |
* /= 4 6.3 |
* > 1 1.6 |
* < 3 4.8 |
* >= 1 1.6 |
* <= 9 14.3 |
* |
* Logic 4 6.3 |
* |
* && (AND-THEN) 1 1.6 |
* | (OR) 1 1.6 |
* ! (NOT) 2 3.2 |
* |
* -- ----- |
* 63 100.1 |
* |
* |
* 3. Operand Type (counted once per operand reference): |
* --------------- |
* number approximate |
* percentage |
* |
* Integer 175 72.3 % |
* Character 45 18.6 % |
* Pointer 12 5.0 % |
* String30 6 2.5 % |
* Array 2 0.8 % |
* Record 2 0.8 % |
* --- ------- |
* 242 100.0 % |
* |
* When there is an access path leading to the final operand (e.g. a record |
* component), only the final data type on the access path is counted. |
* |
* |
* 4. Operand Locality: |
* ------------------- |
* number approximate |
* percentage |
* |
* local variable 114 47.1 % |
* global variable 22 9.1 % |
* parameter 45 18.6 % |
* value 23 9.5 % |
* reference 22 9.1 % |
* function result 6 2.5 % |
* constant 55 22.7 % |
* --- ------- |
* 242 100.0 % |
* |
* |
* The program does not compute anything meaningful, but it is syntactically |
* and semantically correct. All variables have a value assigned to them |
* before they are used as a source operand. |
* |
* There has been no explicit effort to account for the effects of a |
* cache, or to balance the use of long or short displacements for code or |
* data. |
* |
*************************************************************************** |
*/ |
|
/* Compiler and system dependent definitions: */ |
|
#ifdef NOSTRUCTASSIGN |
#define structassign(d, s) memcpy(&(d), &(s), sizeof(d)) |
#else |
#define structassign(d, s) d = s |
#endif |
|
#ifdef NOENUM |
#define Ident_1 0 |
#define Ident_2 1 |
#define Ident_3 2 |
#define Ident_4 3 |
#define Ident_5 4 |
typedef int Enumeration; |
#else |
typedef enum {Ident_1, Ident_2, Ident_3, Ident_4, Ident_5} |
Enumeration; |
#endif |
/* for boolean and enumeration types in Ada, Pascal */ |
|
/* General definitions: */ |
|
#include <stdio.h> |
/* for strcpy, strcmp */ |
|
#define Null 0 |
/* Value of a Null pointer */ |
#define true 1 |
#define false 0 |
|
typedef int One_Thirty; |
typedef int One_Fifty; |
typedef char Capital_Letter; |
typedef int Boolean; |
typedef char Str_30 [31]; |
typedef int Arr_1_Dim [50]; |
typedef int Arr_2_Dim [50] [50]; |
|
typedef struct record |
{ |
struct record *Ptr_Comp; |
Enumeration Discr; |
union { |
struct { |
Enumeration Enum_Comp; |
int Int_Comp; |
char Str_Comp [31]; |
} var_1; |
struct { |
Enumeration E_Comp_2; |
char Str_2_Comp [31]; |
} var_2; |
struct { |
char Ch_1_Comp; |
char Ch_2_Comp; |
} var_3; |
} variant; |
} Rec_Type, *Rec_Pointer; |
|
|
/amber/trunk/sw/dhry/Makefile
0,0 → 1,88
|
SRC = dhry.c dhry_2.c start.S |
TGT = dhry |
LDS = sections.lds |
USE_MINI_LIBC = 1 |
|
LIBC_OBJ = ../mini-libc/printf.o ../mini-libc/libc_asm.o ../mini-libc/memcpy.o |
DEP += ../include/amber_registers.h ../mini-libc/stdio.h |
TOOLSPATH = ../tools |
AMBER_CROSSTOOL ?= amber-crosstool-not-defined |
|
AS = $(AMBER_CROSSTOOL)-as |
CC = $(AMBER_CROSSTOOL)-gcc |
CXX = $(AMBER_CROSSTOOL)-g++ |
AR = $(AMBER_CROSSTOOL)-ar |
LD = $(AMBER_CROSSTOOL)-ld |
DS = $(AMBER_CROSSTOOL)-objdump |
OC = $(AMBER_CROSSTOOL)-objcopy |
ELF = $(TOOLSPATH)/amber-elfsplitter |
BMF = $(TOOLSPATH)/amber-memparams.sh |
|
MMP = $(addsuffix _memparams.v, $(basename $(TGT))) |
MEM = $(addsuffix .mem, $(basename $(TGT))) |
DIS = $(addsuffix .dis, $(basename $(TGT))) |
|
ifdef USE_MINI_LIBC |
OBJ = $(addsuffix .o, $(basename $(SRC))) $(LIBC_OBJ) |
else |
OBJ = $(addsuffix .o, $(basename $(SRC))) |
endif |
|
|
ifdef LDS |
TLDS = -T $(LDS) |
else |
TLDS = |
endif |
|
ifndef TGT |
TGT = aout.elf |
endif |
|
ifdef MIN_SIZE |
# optimize for size |
OPTIMIZE = -Os |
else |
# optimize for speed |
OPTIMIZE = -O3 |
endif |
|
MAP = $(addsuffix .map, $(basename $(TGT))) |
|
ASFLAGS = -I../include |
CFLAGS = -c $(OPTIMIZE) -march=armv2a -mno-thumb-interwork -ffreestanding -I../include |
DSFLAGS = -C -S -EL |
LDFLAGS = -Bstatic -Map $(MAP) --strip-debug --fix-v4bx |
|
|
ifdef USE_MINI_LIBC |
debug: mini-libc $(ELF) $(MMP) $(DIS) |
else |
debug: $(ELF) $(MMP) $(DIS) |
endif |
|
$(MMP): $(MEM) |
$(BMF) $(MEM) $(MMP) |
|
$(MEM): $(TGT) |
$(ELF) $(TGT) > $(MEM) |
|
$(TGT): $(OBJ) |
$(LD) $(LDFLAGS) -o $(TGT) $(TLDS) $(OBJ) |
$(OC) -R .comment -R .note $(TGT) |
|
$(OBJ): $(DEP) |
|
mini-libc: |
$(MAKE) -s -C ../mini-libc MIN_SIZE=1 |
|
$(ELF): |
$(MAKE) -C $(TOOLSPATH) |
|
$(DIS): $(TGT) |
$(DS) $(DSFLAGS) $^ > $@ |
|
clean: |
@rm -rfv *.o *.elf *.dis *.map *.mem *.v $(MMP) dhry |
|
/amber/trunk/sw/dhry/start.S
0,0 → 1,79
/*---------------------------------------------------------------- |
// // |
// start.S // |
// // |
// This file is part of the Amber project // |
// http://www.opencores.org/project,amber // |
// // |
// Description // |
// Assembly routines for hello-world. // |
// As hello-world is a stand-alone application, it needs a // |
// simple start function written in assembly to call the // |
// C code main() function. // |
// // |
// Author(s): // |
// - Conor Santifort, csantifort.amber@gmail.com // |
// // |
////////////////////////////////////////////////////////////////// |
// // |
// Copyright (C) 2010 Authors and OPENCORES.ORG // |
// // |
// This source file may be used and distributed without // |
// restriction provided that this copyright statement is not // |
// removed from the file and that any derivative work contains // |
// the original copyright notice and the associated disclaimer. // |
// // |
// This source file is free software; you can redistribute it // |
// and/or modify it under the terms of the GNU Lesser General // |
// Public License as published by the Free Software Foundation; // |
// either version 2.1 of the License, or (at your option) any // |
// later version. // |
// // |
// This source is distributed in the hope that it will be // |
// useful, but WITHOUT ANY WARRANTY; without even the implied // |
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // |
// PURPOSE. See the GNU Lesser General Public License for more // |
// details. // |
// // |
// You should have received a copy of the GNU Lesser General // |
// Public License along with this source; if not, download it // |
// from http://www.opencores.org/lgpl.shtml // |
// // |
----------------------------------------------------------------*/ |
|
.section .text |
.globl start |
_start: |
/* Switch to User Mode */ |
/* and unset interrupt mask bits */ |
mov r0, #0x00000000 |
teqp pc, r0 |
|
@ Enable the cache |
mov r0, #0xffffffff |
mcr 15, 0, r0, cr3, cr0, 0 @ cacheable area |
mov r0, #1 |
mcr 15, 0, r0, cr2, cr0, 0 @ cache enable |
|
@ initialize malloc |
ldr r1, AdrMalloc |
str r1, [r1] |
|
@ initialize the stack pointer |
ldr sp, AdrStack |
|
@ jump to main |
.extern main |
bl main |
|
b _testpass |
|
/* stack at top of ddr3 memory space */ |
AdrStack: .word 0x8000000 |
AdrMalloc: .word 0x7000000 |
|
|
/* ========================================================================= */ |
/* ========================================================================= */ |
|
|