Drawing a Shape to a Window Using C translated into ARM instructions - c

Question

I am currently trying to learn the ways of C and am using GCC to translate C to ARM instructions. To do so, I am attempting to draw a simple shape to the window, but am having a hard time working out how to do it without using a graphics package like . Here is what I have managed to work out so far:
My make file is pretty self-explanatory I would say.
CC=/cygdrive/c/Users/Ribbyon/Desktop/gcc-arm-none-eabi-5_3-2016q1-20160330-win32/bin/arm-none-eabi-gcc
LD=/cygdrive/c/Users/Ribbyon/Desktop/gcc-arm-none-eabi-5_3-2016q1-20160330-win32/bin/arm-none-eabi-ld.exe
AS=$(CC)
OBJCOPY=/cygdrive/c/Users/Ribbyon/Desktop/gcc-arm-none-eabi-5_3-2016q1-20160330-win32/bin/arm-none-eabi-objcopy.exe
QEMU=/cygdrive/c/Users/Ribbyon/Desktop/qemu/qemu-system-arm.exe
#these should be cross-platform...
CC+= -Wall -c -mcpu=arm926ej-s -marm -Werror
LD+=-Map kernelmap.txt -T linkerscript.txt
AS+= -c -x assembler-with-cpp -mcpu=arm926ej-s
QEMUARGS=-machine integratorcp -kernel kernel.bin -serial stdio
DISPLAY?=:0
export DISPLAY
SDL_STDIO_REDIRECT=no
export SDL_STDIO_REDIRECT
all:
$(AS) kernelasm.s
$(CC) kernelc.c
$(CC) console.c
$(LD) -o kernel.tmp kernelasm.o kernelc.o console.o
$(OBJCOPY) -Obinary kernel.tmp kernel.bin
$(QEMU) $(QEMUARGS) kernel.bin
clean:
-/bin/rm *.o *.exe *.bin *.img *.tmp
Linkerscript to put it together:
ENTRY (_start)
SECTIONS {
/* The kernel will be loaded at this address in RAM.
The dot (.) means "the current location" */
. = 0x10000 ;
.text : {
/* stext = start of text (read-only) section */
stext = .;
/* .text = program code. rodata and rdata = read-only data */
*(.text)
*(.rodata)
*(.rdata)
*(.rdata$zzz)
/* etext = end of text section */
etext = .;
/* pad to a 4K boundary */
. = ALIGN( ABSOLUTE(.) , 0x1000 );
/* start of data (writable) section */
_sdata = .;
sdata = .;
*(.data)
_edata = .;
edata = .;
/* end of data section */
/* bss: Block Started by Symbol: Uninitialized data */
_sbss = . ;
sbss = . ;
*(COMMON)
*(.bss)
_ebss = . ;
ebss = . ;
}
/DISCARD/ : {
*(.eh_frame)
*(.comment)
}
}
Kernel Map (for completeness):
Discarded input sections
.comment 0x0000000000000000 0x33 kernelc.o
.comment 0x0000000000000000 0x33 console.o
Memory Configuration
Name Origin Length Attributes
*default* 0x0000000000000000 0xffffffffffffffff
Linker script and memory map
0x0000000000010000 . = 0x10000
.text 0x0000000000010000 0x2000
0x0000000000010000 stext = .
*(.text)
.text 0x0000000000010000 0x10 kernelasm.o
.text 0x0000000000010010 0x14 kernelc.o
0x0000000000010010 kmain
.text 0x0000000000010024 0x0 console.o
*(.rodata)
*(.rdata)
*(.rdata$zzz)
0x0000000000010024 etext = .
0x0000000000011000 . = ALIGN (ABSOLUTE (.), 0x1000)
*fill* 0x0000000000010024 0xfdc
0x0000000000011000 _sdata = .
0x0000000000011000 sdata = .
*(.data)
.data 0x0000000000011000 0x1000 kernelasm.o
0x0000000000012000 stack
.data 0x0000000000012000 0x0 kernelc.o
.data 0x0000000000012000 0x0 console.o
0x0000000000012000 _edata = .
0x0000000000012000 edata = .
0x0000000000012000 _sbss = .
0x0000000000012000 sbss = .
*(COMMON)
*(.bss)
.bss 0x0000000000012000 0x0 kernelasm.o
.bss 0x0000000000012000 0x0 kernelc.o
.bss 0x0000000000012000 0x0 console.o
0x0000000000012000 _ebss = .
0x0000000000012000 ebss = .
.glue_7 0x0000000000012000 0x0
.glue_7 0x0000000000012000 0x0 linker stubs
.glue_7t 0x0000000000012000 0x0
.glue_7t 0x0000000000012000 0x0 linker stubs
.vfp11_veneer 0x0000000000012000 0x0
.vfp11_veneer 0x0000000000012000 0x0 linker stubs
.v4_bx 0x0000000000012000 0x0
.v4_bx 0x0000000000012000 0x0 linker stubs
.iplt 0x0000000000012000 0x0
.iplt 0x0000000000012000 0x0 kernelasm.o
.igot.plt 0x0000000000012000 0x0
.igot.plt 0x0000000000012000 0x0 kernelasm.o
.rel.dyn 0x0000000000012000 0x0
.rel.iplt 0x0000000000012000 0x0 kernelasm.o
/DISCARD/
*(.eh_frame)
*(.comment)
LOAD kernelasm.o
LOAD kernelc.o
LOAD console.o
OUTPUT(kernel.tmp elf32-littlearm)
.ARM.attributes
0x0000000000000000 0x32
.ARM.attributes
0x0000000000000000 0x24 kernelasm.o
.ARM.attributes
0x0000000000000024 0x36 kernelc.o
.ARM.attributes
0x000000000000005a 0x36 console.o
.note.GNU-stack
0x0000000000000000 0x0
.note.GNU-stack
0x0000000000000000 0x0 kernelc.o
.note.GNU-stack
0x0000000000000000 0x0 console.o
Kernelasm:
ldr sp,=stack
b kmain
forever:
b forever
.section .data
.global stack
.rept 1024
.word 0
.end
stack:
Now, I know in C, I could do something like:
#include<graphics.h>
#include<conio.h>
main()
{
int gd = DETECT, gm;
initgraph(&gd, &gm, "C:\\TC\\BGI");
setcolor(BLUE);
rectangle(50,50,100,100);
getch();
closegraph();
return 0;
}
But since I am working with ARM, it complicates matters. As such, I am thinking I need a kernel.
The actual file that does the work:
#define blue COLOR16(0,0,255)
void console_init(){
}
void setpixel(x, y, blue){
}
The kernel I am using it in:
#include "console.h"
void kmain(){
console_init();
//draw using setpixel
while(1){
}
}
I wrote up the skeleton of it, but I am not sure where to go from here. I believe I need to isolate blue from the RBG band and display it, but I am having a hard time figuring out how to go about utilizing the logic I used in the C example for the ARM.
I think I might need to define width and height of the screen for the placement of the rectangle:
#define WIDTH 800
#define HEIGHT 600
As well as a framebuffer to do the actual communication of where to put the rectangle on the screen:
#define framebuffer ((volatile unsigned short*) (((0x07ffffff - WIDTH*HEIGHT*2))&~0xf))
And a way to assign the blue to the screen:
framebuffer[ HEIGHT/2 * WIDTH + WIDTH/2 ] = #0000FF
Could I use something like a script to grab the colors?
((b >> 3) | (r << 8) | (g << 3))
Any insight would be very helpful in getting the hang of this.