/*
 * Copyright 2005, Ingo Weinhold <bonefish@cs.tu-berlin.de>.
 * All rights reserved. Distributed under the terms of the MIT License.
 *
 *
 * Copyright 2002, Travis Geiselbrecht. All rights reserved.
 * Distributed under the terms of the NewOS License.
 */

#ifdef _BOOT_MODE
#include <boot/arch.h>
#endif

#include <KernelExport.h>

#include <elf_priv.h>
#include <arch/elf.h>


#define CHATTY 0

#ifdef _BOOT_MODE
status_t
boot_arch_elf_relocate_rel(struct preloaded_elf32_image *image, Elf32_Rel *rel,
	int rel_len)
#else
int
arch_elf_relocate_rel(struct elf_image_info *image,
	struct elf_image_info *resolve_image, Elf32_Rel *rel, int rel_len)
#endif
{
	// there are no rel entries in PPC elf
	return B_NO_ERROR;
}


static inline void
write_word32(addr_t P, Elf32_Word value)
{
	*(Elf32_Word*)P = value;
}


static inline void
write_word30(addr_t P, Elf32_Word value)
{
	// bits 0:29
	*(Elf32_Word*)P = (*(Elf32_Word*)P & 0x3) | (value << 2);
}


static inline bool
write_low24_check(addr_t P, Elf32_Word value)
{
	// bits 6:29
	if ((value & 0x3f000000) && (~value & 0x3f800000))
		return false;
	*(Elf32_Word*)P = (*(Elf32_Word*)P & 0xfc000003)
		| ((value & 0x00ffffff) << 2);
	return true;
}


static inline bool
write_low14_check(addr_t P, Elf32_Word value)
{
	// bits 16:29
	if ((value & 0x3fffc000) && (~value & 0x3fffe000))
		return false;
	*(Elf32_Word*)P = (*(Elf32_Word*)P & 0xffff0003)
		| ((value & 0x00003fff) << 2);
	return true;
}


static inline void
write_half16(addr_t P, Elf32_Word value)
{
	// bits 16:29
	*(Elf32_Half*)P = (Elf32_Half)value;
}


static inline bool
write_half16_check(addr_t P, Elf32_Word value)
{
	// bits 16:29
	if ((value & 0xffff0000) && (~value & 0xffff8000))
		return false;
	*(Elf32_Half*)P = (Elf32_Half)value;
	return true;
}


static inline Elf32_Word
lo(Elf32_Word value)
{
	return (value & 0xffff);
}


static inline Elf32_Word
hi(Elf32_Word value)
{
	return ((value >> 16) & 0xffff);
}


static inline Elf32_Word
ha(Elf32_Word value)
{
	return (((value >> 16) + (value & 0x8000 ? 1 : 0)) & 0xffff);
}


#ifdef _BOOT_MODE
status_t
boot_arch_elf_relocate_rela(struct preloaded_elf32_image *image,
	Elf32_Rela *rel, int rel_len)
#else
int
arch_elf_relocate_rela(struct elf_image_info *image,
	struct elf_image_info *resolve_image, Elf32_Rela *rel, int rel_len)
#endif
{
	int i;
	Elf32_Sym *sym;
	int vlErr;

	Elf32_Addr S = 0;	// symbol address
	addr_t R = 0;		// section relative symbol address

	addr_t G = 0;		// GOT address
	addr_t L = 0;		// PLT address

	#define P	((addr_t)(image->text_region.delta + rel[i].r_offset))
	#define A	((addr_t)rel[i].r_addend)
	#define B	(image->text_region.delta)

	// TODO: Get the GOT address!
	#define REQUIRE_GOT	\
		if (G == 0) {	\
			dprintf("arch_elf_relocate_rela(): Failed to get GOT address!\n"); \
			return B_ERROR;	\
		}

	// TODO: Get the PLT address!
	#define REQUIRE_PLT	\
		if (L == 0) {	\
			dprintf("arch_elf_relocate_rela(): Failed to get PLT address!\n"); \
			return B_ERROR;	\
		}

	for (i = 0; i * (int)sizeof(Elf32_Rela) < rel_len; i++) {
#if CHATTY
		dprintf("looking at rel type %d, offset 0x%lx, sym 0x%lx, addend 0x%lx\n",
			ELF32_R_TYPE(rel[i].r_info), rel[i].r_offset, ELF32_R_SYM(rel[i].r_info), rel[i].r_addend);
#endif
		switch (ELF32_R_TYPE(rel[i].r_info)) {
			case R_PPC_SECTOFF:
			case R_PPC_SECTOFF_LO:
			case R_PPC_SECTOFF_HI:
			case R_PPC_SECTOFF_HA:
				dprintf("arch_elf_relocate_rela(): Getting section relative "
					"symbol addresses not yet supported!\n");
				return B_ERROR;

			case R_PPC_ADDR32:
			case R_PPC_ADDR24:
			case R_PPC_ADDR16:
			case R_PPC_ADDR16_LO:
			case R_PPC_ADDR16_HI:
			case R_PPC_ADDR16_HA:
			case R_PPC_ADDR14:
			case R_PPC_ADDR14_BRTAKEN:
			case R_PPC_ADDR14_BRNTAKEN:
			case R_PPC_REL24:
			case R_PPC_REL14:
			case R_PPC_REL14_BRTAKEN:
			case R_PPC_REL14_BRNTAKEN:
			case R_PPC_GLOB_DAT:
			case R_PPC_UADDR32:
			case R_PPC_UADDR16:
			case R_PPC_REL32:
			case R_PPC_SDAREL16:
			case R_PPC_ADDR30:
			case R_PPC_JMP_SLOT:
				sym = SYMBOL(image, ELF32_R_SYM(rel[i].r_info));

#ifdef _BOOT_MODE
				vlErr = boot_elf_resolve_symbol(image, sym, &S);
#else
				vlErr = elf_resolve_symbol(image, sym, resolve_image, &S);
#endif
				if (vlErr < 0) {
					dprintf("%s(): Failed to relocate "
						"entry index %d, rel type %d, offset 0x%lx, sym 0x%lx, "
						"addend 0x%lx\n", __FUNCTION__, i, ELF32_R_TYPE(rel[i].r_info),
						rel[i].r_offset, ELF32_R_SYM(rel[i].r_info),
						rel[i].r_addend);
					return vlErr;
				}
				break;
		}

		switch (ELF32_R_TYPE(rel[i].r_info)) {
			case R_PPC_NONE:
				break;

			case R_PPC_COPY:
				// TODO: Implement!
				dprintf("arch_elf_relocate_rela(): R_PPC_COPY not yet "
					"supported!\n");
				return B_ERROR;

			case R_PPC_ADDR32:
			case R_PPC_GLOB_DAT:
			case R_PPC_UADDR32:
				write_word32(P, S + A);
				break;

			case R_PPC_ADDR24:
				if (write_low24_check(P, (S + A) >> 2))
					break;
dprintf("R_PPC_ADDR24 overflow\n");
				return B_BAD_DATA;

			case R_PPC_ADDR16:
			case R_PPC_UADDR16:
				if (write_half16_check(P, S + A))
					break;
dprintf("R_PPC_ADDR16 overflow\n");
				return B_BAD_DATA;

			case R_PPC_ADDR16_LO:
				write_half16(P, lo(S + A));
				break;

			case R_PPC_ADDR16_HI:
				write_half16(P, hi(S + A));
				break;

			case R_PPC_ADDR16_HA:
				write_half16(P, ha(S + A));
				break;

			case R_PPC_ADDR14:
			case R_PPC_ADDR14_BRTAKEN:
			case R_PPC_ADDR14_BRNTAKEN:
				if (write_low14_check(P, (S + A) >> 2))
					break;
dprintf("R_PPC_ADDR14 overflow\n");
				return B_BAD_DATA;

			case R_PPC_REL24:
				if (write_low24_check(P, (S + A - P) >> 2))
					break;
dprintf("R_PPC_REL24 overflow: 0x%lx\n", (S + A - P) >> 2);
				return B_BAD_DATA;

			case R_PPC_REL14:
			case R_PPC_REL14_BRTAKEN:
			case R_PPC_REL14_BRNTAKEN:
				if (write_low14_check(P, (S + A - P) >> 2))
					break;
dprintf("R_PPC_REL14 overflow\n");
				return B_BAD_DATA;

			case R_PPC_GOT16:
				REQUIRE_GOT;
				if (write_half16_check(P, G + A))
					break;
dprintf("R_PPC_GOT16 overflow\n");
				return B_BAD_DATA;

			case R_PPC_GOT16_LO:
				REQUIRE_GOT;
				write_half16(P, lo(G + A));
				break;

			case R_PPC_GOT16_HI:
				REQUIRE_GOT;
				write_half16(P, hi(G + A));
				break;

			case R_PPC_GOT16_HA:
				REQUIRE_GOT;
				write_half16(P, ha(G + A));
				break;

			case R_PPC_JMP_SLOT:
			{
				// If the relative offset is small enough, we fabricate a
				// relative branch instruction ("b <addr>").
				addr_t jumpOffset = S - P;
				if ((jumpOffset & 0xfc000000) != 0
					&& (~jumpOffset & 0xfe000000) != 0) {
					// Offset > 24 bit.
					// TODO: Implement!
					// See System V PPC ABI supplement, p. 5-6!
					dprintf("arch_elf_relocate_rela(): R_PPC_JMP_SLOT: "
						"Offsets > 24 bit currently not supported!\n");
dprintf("jumpOffset: %p\n", (void*)jumpOffset);
					return B_ERROR;
				} else {
					// Offset <= 24 bit
					// 0:5 opcode (= 18), 6:29 address, 30 AA, 31 LK
					// "b" instruction: opcode = 18, AA = 0, LK = 0
					// address: 24 high-order bits of 26 bit offset
					*(uint32*)P = 0x48000000 | ((jumpOffset) & 0x03fffffc);
				}
				break;
			}

			case R_PPC_RELATIVE:
				write_word32(P, B + A);
				break;

			case R_PPC_LOCAL24PC:
// TODO: Implement!
// low24*
// 				if (write_low24_check(P, ?)
// 					break;
// 				return B_BAD_DATA;
				dprintf("arch_elf_relocate_rela(): R_PPC_LOCAL24PC not yet "
					"supported!\n");
				return B_ERROR;

			case R_PPC_REL32:
				write_word32(P, S + A - P);
				break;

			case R_PPC_PLTREL24:
				REQUIRE_PLT;
				if (write_low24_check(P, (L + A - P) >> 2))
					break;
dprintf("R_PPC_PLTREL24 overflow\n");
				return B_BAD_DATA;

			case R_PPC_PLT32:
				REQUIRE_PLT;
				write_word32(P, L + A);
				break;

			case R_PPC_PLTREL32:
				REQUIRE_PLT;
				write_word32(P, L + A - P);
				break;

			case R_PPC_PLT16_LO:
				REQUIRE_PLT;
				write_half16(P, lo(L + A));
				break;

			case R_PPC_PLT16_HI:
				REQUIRE_PLT;
				write_half16(P, hi(L + A));
				break;

			case R_PPC_PLT16_HA:
				write_half16(P, ha(L + A));
				break;

			case R_PPC_SDAREL16:
// TODO: Implement!
// 				if (write_half16_check(P, S + A - _SDA_BASE_))
// 					break;
// 				return B_BAD_DATA;
				dprintf("arch_elf_relocate_rela(): R_PPC_SDAREL16 not yet "
					"supported!\n");
				return B_ERROR;

			case R_PPC_SECTOFF:
				if (write_half16_check(P, R + A))
					break;
dprintf("R_PPC_SECTOFF overflow\n");
				return B_BAD_DATA;

			case R_PPC_SECTOFF_LO:
				write_half16(P, lo(R + A));
				break;

			case R_PPC_SECTOFF_HI:
				write_half16(P, hi(R + A));
				break;

			case R_PPC_SECTOFF_HA:
				write_half16(P, ha(R + A));
				break;

			case R_PPC_ADDR30:
				write_word30(P, (S + A - P) >> 2);
				break;

			default:
				dprintf("arch_elf_relocate_rela: unhandled relocation type %d\n", ELF32_R_TYPE(rel[i].r_info));
				return B_ERROR;
		}
	}

	return B_NO_ERROR;
}