/////////////////////////////////////Linker script/////////////////////////////////////

MEMORY {
	RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 128K
	FLASH (rx)      : ORIGIN = 0x8000000, LENGTH = 512K
}

ENTRY(_start);

EXTERN(RESET_VECTOR);
EXTERN(EXCEPTIONS);

SECTIONS {
	.vector_table : ALIGN(4) {
		FILL(0xFF)
		LONG(ORIGIN(RAM) + LENGTH(RAM));
		KEEP(*(.vector_table.reset_vector));

		KEEP(*(.vector_table.exceptions));
	} > FLASH

	.text : {
		. = ALIGN(4);
	 	*(.text .text.*);
	} > FLASH

	.rodata : {
		. = ALIGN(4);

		*(.rodata .rodata.*);

		. = ALIGN(4);
	} > FLASH

	.bss :
	{
		. = ALIGN(4);
		_sbss = .;

		*(.bss .bss.*);
		*(COMMON);

		. = ALIGN(4);
		_ebss = .;
	} > RAM

	.data : AT(ADDR(.rodata) + SIZEOF(.rodata))
	{
		. = ALIGN(4);
		_sdata = .;

		*(.data .data.*);

		. = ALIGN(4);
		_edata = .;
	} > RAM

	_sidata = LOADADDR(.data);

	/DISCARD/ : {
		*(.ARM.exidx .ARM.exidx.*);
	}
}

PROVIDE(NMI = DefaultExceptionHandler);
PROVIDE(HardFault = DefaultExceptionHandler);
PROVIDE(MemManage = DefaultExceptionHandler);
PROVIDE(BusFault = DefaultExceptionHandler);
PROVIDE(UsageFault = DefaultExceptionHandler);
PROVIDE(SVCall = DefaultExceptionHandler);
PROVIDE(PendSV = DefaultExceptionHandler);
PROVIDE(SysTick = DefaultExceptionHandler);

/////////////////////////////////// main.zig ///////////////////////////////
extern var _sbss: u8;
extern var _ebss: u8;

extern var _sdata: u8;
extern var _edata: u8;
extern const _sidata: u8;

export const RESET_VECTOR linksection(".vector_table.reset_vector") = _start;

const std = @import("std");
const mem = std.mem;

var text = "ditiseentest";
var x: [100]u32 = undefined;
var y: u32 = 0xff;

export nakedcc fn _start() noreturn {
    // clear bss section
    const bss_length = @ptrToInt(&_ebss) - @ptrToInt(&_sbss);
    const bss_section = @ptrCast([*]u8, &_sbss);
    mem.set(u8, bss_section[0..bss_length], 0);

    const data_length = @ptrToInt(&_edata) - @ptrToInt(&_sdata);
    const data_section = @ptrCast([*]u8, &_sdata);
    const source_data_section = @ptrCast([*]const u8, &_sidata);
    mem.copy(u8, data_section[0..data_length], source_data_section[0..data_length]);

    main();
}

const Vector = packed union {
    reserved: u32,
    handler: extern fn() noreturn
};

extern fn NMI() noreturn;
extern fn HardFault() noreturn;
extern fn MemManage() noreturn;
extern fn BusFault() noreturn;
extern fn UsageFault() noreturn;
extern fn SVCall() noreturn;
extern fn PendSV() noreturn;
extern fn SysTick() noreturn;

export const EXCEPTIONS: [14]Vector linksection(".vector_table.exceptions") = [14]Vector{
    Vector { .handler = NMI },
    Vector { .handler = HardFault },
    Vector { .handler = MemManage },
    Vector { .handler = BusFault },
    Vector {
        .handler = UsageFault,
    },
    Vector { .reserved = 0 },
    Vector { .reserved = 0 },
    Vector { .reserved = 0 },
    Vector { .reserved = 0 },
    Vector { .handler = SVCall },
    Vector { .reserved = 0 },
    Vector { .reserved = 0 },
    Vector { .handler = PendSV },
    Vector { .handler = SysTick },
};

export fn DefaultExceptionHandler() noreturn {
    while(true) {}
}

fn main() noreturn {
    for (x) |*item, i| {
        item.* = @intCast(u32, i);
    }

    var _text = &text;
    var _x = &x;
    var _y = &y;



    while(true) {}
}

//////////////////////////////// build.zig ///////////////////////////
const Builder = @import("std").build.Builder;
const builtin = @import("builtin");

pub fn build(b: *Builder) void {
    const mode = b.standardReleaseOptions();
    const exe = b.addExecutable("stm32", "src/main.zig");
    exe.setBuildMode(mode);

    const arch = builtin.Arch{ .thumb = .v7m };
    const environ = builtin.Abi.eabi;
    exe.setTarget(arch, .freestanding, environ);

    exe.setLinkerScriptPath("src/linker.ld");
    exe.setOutputDir("zig-cache");

    b.default_step.dependOn(&exe.step);
}