some new headers.

libPS4/include/elf64.h

@@ -0,0 +1,230 @@
+ /*  
+  *  This file is taken out of the internet from  torvalds github and is open source.
+  *  https://github.com/torvalds/linux/blob/master/include/uapi/linux/elf.h
+  *
+  */
+
+#ifndef ELF64_H
+#define ELF64_H
+
+#include "types.h"
+
+#define EI_NIDENT 16
+
+/* These constants define the different elf file types */
+#define ET_NONE   0
+#define ET_REL    1
+#define ET_EXEC   2
+#define ET_DYN    3
+#define ET_CORE   4
+#define ET_LOPROC 0xff00
+#define ET_HIPROC 0xffff
+
+/* This is the info that is needed to parse the dynamic section of the file */
+#define DT_NULL		     0
+#define DT_NEEDED	     1
+#define DT_PLTRELSZ	   2
+#define DT_PLTGOT	     3
+#define DT_HASH		     4
+#define DT_STRTAB	     5
+#define DT_SYMTAB	     6
+#define DT_RELA		     7
+#define DT_RELASZ	     8
+#define DT_RELAENT	   9
+#define DT_STRSZ	    10
+#define DT_SYMENT	    11
+#define DT_INIT		    12
+#define DT_FINI		    13
+#define DT_SONAME	    14
+#define DT_RPATH 	    15
+#define DT_SYMBOLIC	  16
+#define DT_REL	      17
+#define DT_RELSZ	    18
+#define DT_RELENT	    19
+#define DT_PLTREL	    20
+#define DT_DEBUG	    21
+#define DT_TEXTREL	  22
+#define DT_JMPREL	    23
+#define DT_ENCODING	  32
+#define OLD_DT_LOOS	  0x60000000
+#define DT_LOOS		    0x6000000d
+#define DT_HIOS		    0x6ffff000
+#define DT_VALRNGLO	  0x6ffffd00
+#define DT_VALRNGHI	  0x6ffffdff
+#define DT_ADDRRNGLO	0x6ffffe00
+#define DT_ADDRRNGHI	0x6ffffeff
+#define DT_VERSYM	    0x6ffffff0
+#define DT_RELACOUNT	0x6ffffff9
+#define DT_RELCOUNT	  0x6ffffffa
+#define DT_FLAGS_1	  0x6ffffffb
+#define DT_VERDEF	    0x6ffffffc
+#define	DT_VERDEFNUM	0x6ffffffd
+#define DT_VERNEED	  0x6ffffffe
+#define	DT_VERNEEDNUM	0x6fffffff
+#define OLD_DT_HIOS   0x6fffffff
+#define DT_LOPROC	    0x70000000
+#define DT_HIPROC	    0x7fffffff
+
+/* These constants are for the segment types stored in the image headers */
+#define PT_NULL    0
+#define PT_LOAD    1
+#define PT_DYNAMIC 2
+#define PT_INTERP  3
+#define PT_NOTE    4
+#define PT_SHLIB   5
+#define PT_PHDR    6
+#define PT_TLS     7               /* Thread local storage segment */
+#define PT_LOOS    0x60000000      /* OS-specific */
+#define PT_HIOS    0x6fffffff      /* OS-specific */
+#define PT_LOPROC  0x70000000
+#define PT_HIPROC  0x7fffffff
+#define PT_GNU_EH_FRAME		0x6474e550
+
+#define PT_GNU_STACK	(PT_LOOS + 0x474e551)
+
+/* This info is needed when parsing the symbol table */
+#define STB_LOCAL  0
+#define STB_GLOBAL 1
+#define STB_WEAK   2
+
+#define STT_NOTYPE  0
+#define STT_OBJECT  1
+#define STT_FUNC    2
+#define STT_SECTION 3
+#define STT_FILE    4
+#define STT_COMMON  5
+#define STT_TLS     6
+
+#define ELF_ST_BIND(x)		((x) >> 4)
+#define ELF_ST_TYPE(x)		(((unsigned int) x) & 0xf)
+#define ELF64_ST_BIND(x)	ELF_ST_BIND(x)
+#define ELF64_ST_TYPE(x)	ELF_ST_TYPE(x)
+
+/* 64-bit ELF base types. */
+typedef __u64	Elf64_Addr;
+typedef __u16	Elf64_Half;
+typedef __s16	Elf64_SHalf;
+typedef __u64	Elf64_Off;
+typedef __s32	Elf64_Sword;
+typedef __u32	Elf64_Word;
+typedef __u64	Elf64_Xword;
+typedef __s64	Elf64_Sxword;
+
+/* 64-bit ELF Header. */
+typedef struct elf64_hdr {
+  unsigned char	e_ident[EI_NIDENT];	 /* ELF "magic number" */
+  Elf64_Half e_type;
+  Elf64_Half e_machine;
+  Elf64_Word e_version;
+  Elf64_Addr e_entry;		               /* Entry point virtual address */
+  Elf64_Off e_phoff;		               /* Program header table file offset */
+  Elf64_Off e_shoff;		               /* Section header table file offset */
+  Elf64_Word e_flags;
+  Elf64_Half e_ehsize;
+  Elf64_Half e_phentsize;
+  Elf64_Half e_phnum;
+  Elf64_Half e_shentsize;
+  Elf64_Half e_shnum;
+  Elf64_Half e_shstrndx;
+} Elf64_Ehdr;
+
+/* These constants define the permissions on sections in the program
+   header, p_flags. */
+#define PF_R		0x4
+#define PF_W		0x2
+#define PF_X		0x1
+
+/* 64-bit ELF p Header. */
+typedef struct elf64_phdr {
+  Elf64_Word p_type;
+  Elf64_Word p_flags;
+  Elf64_Off p_offset;		  /* Segment file offset */
+  Elf64_Addr p_vaddr;		  /* Segment virtual address */
+  Elf64_Addr p_paddr;		  /* Segment physical address */
+  Elf64_Xword p_filesz;		/* Segment size in file */
+  Elf64_Xword p_memsz;		/* Segment size in memory */
+  Elf64_Xword p_align;		/* Segment alignment, file & memory */
+} Elf64_Phdr;
+
+/* 64-bit ELF dynamical structure. */
+typedef struct {
+  Elf64_Sxword d_tag;		  /* entry tag value */
+  union {
+    Elf64_Xword d_val;
+    Elf64_Addr d_ptr;
+  } d_un;
+} Elf64_Dyn;
+
+/* The following are used with relocations */
+#define ELF64_R_SYM(i)			((i) >> 32)
+#define ELF64_R_TYPE(i)			((i) & 0xffffffff)
+
+typedef struct elf64_rel {
+  Elf64_Addr r_offset;	    /* Location at which to apply the action */
+  Elf64_Xword r_info;	      /* index and type of relocation */
+} Elf64_Rel;
+
+typedef struct elf64_rela {
+  Elf64_Addr r_offset;	    /* Location at which to apply the action */
+  Elf64_Xword r_info;	      /* index and type of relocation */
+  Elf64_Sxword r_addend;	  /* Constant addend used to compute value */
+} Elf64_Rela;
+
+/* 64-bit ELF symbol structure. */
+typedef struct elf64_sym {
+  Elf64_Word st_name;		    /* Symbol name, index in string tbl */
+  unsigned char	st_info;	/* Type and binding attributes */
+  unsigned char	st_other;	/* No defined meaning, 0 */
+  Elf64_Half st_shndx;		  /* Associated section index */
+  Elf64_Addr st_value;		  /* Value of the symbol */
+  Elf64_Xword st_size;		  /* Associated symbol size */
+} Elf64_Sym;
+
+/* sh_type */
+#define SHT_NULL	     0
+#define SHT_PROGBITS   1
+#define SHT_SYMTAB	   2
+#define SHT_STRTAB	   3
+#define SHT_RELA	     4
+#define SHT_HASH	     5
+#define SHT_DYNAMIC	   6
+#define SHT_NOTE	     7
+#define SHT_NOBITS	   8
+#define SHT_REL		     9
+#define SHT_SHLIB	    10
+#define SHT_DYNSYM	  11
+#define SHT_NUM		    12
+#define SHT_LOPROC	  0x70000000
+#define SHT_HIPROC	  0x7fffffff
+#define SHT_LOUSER	  0x80000000
+#define SHT_HIUSER	  0xffffffff
+
+/* sh_flags */
+#define SHF_WRITE	    0x1
+#define SHF_ALLOC	    0x2
+#define SHF_EXECINSTR	0x4
+#define SHF_MASKPROC	0xf0000000
+
+/* special section indexes */
+#define SHN_UNDEF	0
+#define SHN_LORESERVE	0xff00
+#define SHN_LOPROC	  0xff00
+#define SHN_HIPROC	  0xff1f
+#define SHN_ABS		    0xfff1
+#define SHN_COMMON	  0xfff2
+#define SHN_HIRESERVE	0xffff
+
+typedef struct elf64_shdr {
+  Elf64_Word sh_name;		    /* Section name, index in string tbl */
+  Elf64_Word sh_type;		    /* Type of section */
+  Elf64_Xword sh_flags;		  /* Miscellaneous section attributes */
+  Elf64_Addr sh_addr;		    /* Section virtual addr at execution */
+  Elf64_Off sh_offset;		  /* Section file offset */
+  Elf64_Xword sh_size;		  /* Size of section in bytes */
+  Elf64_Word sh_link;		    /* Index of another section */
+  Elf64_Word sh_info;		    /* Additional section information */
+  Elf64_Xword sh_addralign;	/* Section alignment */
+  Elf64_Xword sh_entsize;	  /* Entry size if section holds table */
+} Elf64_Shdr;
+
+#endif

libPS4/include/ps4.h

@@ -20,3 +20,5 @@
 #include "pad.h"
 #include "graphics.h"
 #include "jit.h"
+#include "system64.h"
+#include "elf64.h"

libPS4/include/system64.h

@@ -0,0 +1,85 @@
+/*
+ *  this file was mostly taken out of the internet here:
+ *  http://lxr.free-electrons.com/source/include/asm-x86/system_64.h?v=2.6.24
+ *
+ *  I just swapped some asm moveq instructions to make it work for the PS4.
+ *  
+ */
+
+#ifndef SYSTEM64_H
+#define SYSTEM64_H
+
+#include "types.h"
+
+#define nop() __asm__ __volatile__ ("nop")                          // No Operation.
+#define cli() __asm__ __volatile__ ("cli")                          // Disable interrrupts.
+#define sti() __asm__ __volatile__ ("sti")                          // Enable interrupts.
+#define hlt() __asm__ __volatile__ ("hlt")                          // Turn CPU into HALT state (power saving mode C1).
+#define stp() __asm__ __volatile__ (sti() hlt() : : : "memory")     // Turn CPU into STOP.
+#define clts() __asm__ __volatile__ ("clts")                        // Clear 'TS' bit respectively.
+#define stts() write_cr0(8 | read_cr0())                            // Set 'TS' bit.
+#define wbinvd() __asm__ __volatile__ ("wbinvd": : :"memory")       // Flush the L1 cache without losing information. ("Write Back and Invalidate")
+
+// Read the value of write protection and return it.
+static inline uint64_t read_cr0(void)
+{
+	uint64_t cr0;
+	asm volatile ("movq %0, %%cr0;" : "=r" (cr0) : : "memory");
+	return cr0;
+}
+
+// Write a value to the write protection.
+static inline void write_cr0(uint64_t cr0)
+{
+	asm volatile ("movq %%cr0, %0;" :: "r" (cr0) : "memory");
+}
+
+static inline uint64_t read_cr2(void)
+{
+  uint64_t cr2;
+  asm volatile("movq %0, %%cr2" : "=r" (cr2));
+  return cr2;
+}
+
+static inline void write_cr2(uint64_t val)
+{
+  asm volatile("movq %%cr2, %0" :: "r" (val));
+}
+
+static inline uint64_t read_cr3(void)
+{ 
+  uint64_t cr3;
+  asm volatile("movq %0, %%cr3" : "=r" (cr3));
+  return cr3;
+}
+
+static inline void write_cr3(uint64_t val)
+{
+  asm volatile("movq %%cr3, %0" :: "r" (val) : "memory");
+}
+
+static inline uint64_t read_cr4(void)
+{ 
+  uint64_t cr4;
+  asm volatile("movq %0, %%cr4" : "=r" (cr4));
+  return cr4;
+}
+
+static inline void write_cr4(uint64_t val)
+{ 
+  asm volatile("movq %%cr4, %0" :: "r" (val) : "memory");
+}
+
+static inline uint64_t read_cr8(void)
+{
+  uint64_t cr8;
+  asm volatile("movq %0, %%cr8" : "=r" (cr8));
+  return cr8;
+}
+
+static inline void write_cr8(uint64_t val)
+{
+  asm volatile("movq %%cr8, %0" :: "r" (val) : "memory");
+}
+
+#endif