--- /dev/null
+ rm coreboot.rom;
+./cbfstool coreboot.rom create 0x80000 0x10000 /tmp/coreboot.strip
+./cbfstool coreboot.rom add-payload /tmp/filo.elf normal/payload l
+./cbfstool coreboot.rom print
+#./cbfstool coreboot.rom add-stage /tmp/filo.elf normal/payload
+
+./cbfstool coreboot.rom print
+cp coreboot.rom /home/rminnich/qemutest/
--- /dev/null
+#
+#
+#
+
+obj ?= $(shell pwd)
+
+COMMANDS=create.o bootblock.o delete.o add.o print.o resize.o
+OBJ=$(COMMANDS) cbfstool.o util.o fs.o
+INC=cbfstool.h cbfs.h
+
+CC=gcc
+CFLAGS=-g -Wall # -W -Werror
+
+DESTDIR ?= /usr/local/bin
+
+all: $(obj)/cbfstool $(obj)/tools/rom-mkpayload $(obj)/tools/rom-mkstage
+
+$(obj)/cbfstool: $(patsubst %,$(obj)/%,$(OBJ))
+ $(CC) -o $@ $(patsubst %,$(obj)/%,$(OBJ))
+
+tobj = $(obj)/tools
+tsrc = $(shell pwd)/tools
+
+include $(tsrc)/Makefile
+
+$(obj)/%.o: %.c $(INC)
+ $(CC) $(CFLAGS) -c -o $@ $<
+
+install: $(obj)/cbfstool $(obj)/tools/rom-mkpayload $(obj)/tools/rom-mkstage
+ @ install -d $(DESTDIR)
+ @ install -m 0755 $(obj)/cbfstool $(DESTDIR)/cbfstool
+ @ install -m 0755 $(obj)/tools/rom-mkstage $(DESTDIR)/rom-mkstage
+ @ install -m 0755 $(obj)/tools/rom-mkpayload $(DESTDIR)/rom-mkpayload
+
+tags:
+ ctags *.[ch] */*.[ch]
+
+clean: tools-clean
+ rm -f $(patsubst %,$(obj)/%,$(OBJ)) $(obj)/cbfstool
+
--- /dev/null
+Coreboot CBFS Specification
+Jordan Crouse <jordan@cosmicpenguin.net>
+
+= Introduction =
+
+This document describes the coreboot CBFS specification (from here referred
+to as CBFS). CBFS is a scheme for managing independent chunks of data in
+a system ROM. Though not a true filesystem, the style and concepts are
+similar.
+
+= Architecture =
+
+The CBFS architecture looks like the following:
+
+/---------------\ <-- Start of ROM
+| /-----------\ | --|
+| | Header | | |
+| |-----------| | |
+| | Name | | |-- Component
+| |-----------| | |
+| |Data | | |
+| |.. | | |
+| \-----------/ | --|
+| |
+| /-----------\ |
+| | Header | |
+| |-----------| |
+| | Name | |
+| |-----------| |
+| |Data | |
+| |.. | |
+| \-----------/ |
+| |
+| ... |
+| /-----------\ |
+| | | |
+| | Bootblock | |
+| | --------- | |
+| | Reset | | <- 0xFFFFFFF0
+| \-----------/ |
+\---------------/
+
+
+The CBFS architecture consists of a binary associated with a physical
+ROM disk referred hereafter as the ROM. A number of independent of
+components, each with a header prepended on to data are located within
+the ROM. The components are nominally arranged sequentially, though they
+are aligned along a pre-defined boundary.
+
+The bootblock occupies the last 20k of the ROM. Within
+the bootblock is a master header containing information about the ROM
+including the size, alignment of the components, and the offset of the
+start of the first CBFS component within the ROM.
+
+= Master Header =
+
+The master header contains essential information about the ROM that is
+used by both the CBFS implementation within coreboot at runtime as well
+as host based utilities to create and manage the ROM. The master header
+will be located somewhere within the bootblock (high end of the ROM). A
+pointer to the location of the header will be located at offset
+-4 from the end of the ROM. This translates to address 0xFFFFFFFC on a
+normal x86 system. The pointer will be to physical memory somewhere
+between - 0xFFFF0000 and 0xFFFFFFF0. This makes it easier for coreboot
+to locate the header at run time. Build time utilities will
+need to read the pointer and do the appropriate math to locate the header.
+
+The following is the structure of the master header:
+
+struct cbfs_header {
+ unsigned int magic;
+ unsigned int version;
+ unsigned int romsize;
+ unsigned int bootblocksize;
+ unsigned int align;
+ unsigned int offset;
+ unsigned int pad[2];
+};
+
+The meaning of each member is as follows:
+
+'magic' is a 32 bit number that identifies the ROM as a CBFS type. The magic
+number is 0x4F524243, which is 'ORBC' in ASCII.
+
+'version' is a 32 bit number that identifies the version of CBFS. The current
+version is 0x31313131 ('1111' in ASCII) which is endian-independent.
+
+'romsize' is the size of the ROM in bytes. Coreboot will subtract 'size' from
+0xFFFFFFFF to locate the beginning of the ROM in memory.
+
+'bootblocksize' is the boot block size in bytes. There is no limitation on
+the boot block size as in v3.
+
+'align' is the number of bytes that each component is aligned to within the
+ROM. This is used to make sure that each component is aligned correctly with
+regards to the erase block sizes on the ROM - allowing one to replace a
+component at runtime without disturbing the others.
+
+'offset' is the offset of the the first CBFS component (from the start of
+the ROM). This is to allow for arbitrary space to be left at the beginning
+of the ROM for things like embedded controller firmware.
+
+'pad' rounds the header to 32 bits and reserves a little room for later use.
+
+= Bootblock =
+The bootblock is a mandatory component in the ROM. It is located in the
+last bootblocksize bytes of ROM space, and contains, among other things,
+the location of the master header and the entry point for the loader
+firmware. The bootblock does not have a component header attached to it.
+
+
+= Components =
+
+CBFS components are placed in the ROM starting at 'offset' specified in
+the master header and ending at the bootblock. Thus the total size available
+for components in the ROM is (ROM size - bootblocksize - 'offset'). Each CBFS
+component is to be aligned according to the 'align' value in the header.
+Thus, if a component of size 1052 is located at offset 0 with an 'align' value
+of 1024, the next component will be located at offset 2048.
+
+Each CBFS component will be indexed with a unique ASCII string name of
+unlimited size.
+
+Each CBFS component starts with a header:
+
+struct CBFS_file {
+ char magic[8];
+ unsigned int len;
+ unsigned int type;
+ unsigned int checksum;
+ unsigned int offset;
+};
+
+'magic' is a magic value used to identify the header. During runtime,
+coreboot will scan the ROM looking for this value. The default magic is
+the string 'LARCHIVE'.
+
+'len' is the length of the data, not including the size of the header and
+the size of the name.
+
+'type' is a 32 bit number indicating the type of data that is attached.
+The data type is used in a number of ways, as detailed in the section
+below.
+
+'checksum' is a 32bit checksum of the entire component, including the
+header and name.
+
+'offset' is the start of the component data, based off the start of the header.
+The difference between the size of the header and offset is the size of the
+component name.
+
+Immediately following the header will be the name of the component, which will
+null terminated and 16 byte aligned. The following picture shows the
+structure of the header:
+
+/--------\ <- start
+| Header |
+|--------| <- sizeof(struct cbfs_file)
+| Name |
+|--------| <- 'offset'
+| Data |
+| ... |
+\--------/ <- start + 'offset' + 'len'
+
+== Searching Alogrithm ==
+
+To locate a specific component in the ROM, one starts at the 'offset'
+specified in the CBFS master header. For this example, the offset will
+be 0.
+
+From that offset, the code should search for the magic string on the
+component, jumping 'align' bytes each time. So, assuming that 'align' is
+16, the code will search for the string 'LARCHIVE' at offset 0, 16, 32, etc.
+If the offset ever exceeds the allowable range for CBFS components, then no
+component was found.
+
+Upon recognizing a component, the software then has to search for the
+specific name of the component. This is accomplished by comparing the
+desired name with the string on the component located at
+offset + sizeof(struct cbfs_file). If the string matches, then the component
+has been located, otherwise the software should add 'offset' + 'len' to
+the offset and resume the search for the magic value.
+
+== Data Types ==
+
+The 'type' member of struct cbfs_file is used to identify the content
+of the component data, and is used by coreboot and other
+run-time entities to make decisions about how to handle the data.
+
+There are three component types that are essential to coreboot, and so
+are defined here.
+
+=== Stages ===
+
+Stages are code loaded by coreboot during the boot process. They are
+essential to a successful boot. Stages are comprised of a single blob
+of binary data that is to be loaded into a particular location in memory
+and executed. The uncompressed header contains information about how
+large the data is, and where it should be placed, and what additional memory
+needs to be cleared.
+
+Stages are assigned a component value of 0x10. When coreboot sees this
+component type, it knows that it should pass the data to a sub-function
+that will process the stage.
+
+The following is the format of a stage component:
+
+/--------\
+| Header |
+|--------|
+| Binary |
+| .. |
+\--------/
+
+The header is defined as:
+
+struct cbfs_stage {
+ unsigned int compression;
+ unsigned long long entry;
+ unsigned long long load;
+ unsigned int len;
+ unsigned int memlen;
+};
+
+'compression' is an integer defining how the data is compressed. There
+are three compression types defined by this version of the standard:
+none (0x0), lzma (0x1), and nrv2b (0x02), though additional types may be
+added assuming that coreboot understands how to handle the scheme.
+
+'entry' is a 64 bit value indicating the location where the program
+counter should jump following the loading of the stage. This should be
+an absolute physical memory address.
+
+'load' is a 64 bit value indicating where the subsequent data should be
+loaded. This should be an absolute physical memory address.
+
+'len' is the length of the compressed data in the component.
+
+'memlen' is the amount of memory that will be used by the component when
+it is loaded.
+
+The component data will start immediately following the header.
+
+When coreboot loads a stage, it will first zero the memory from 'load' to
+'memlen'. It will then decompress the component data according to the
+specified scheme and place it in memory starting at 'load'. Following that,
+it will jump execution to the address specified by 'entry'.
+Some components are designed to execute directly from the ROM - coreboot
+knows which components must do that and will act accordingly.
+
+=== Payloads ===
+
+Payloads are loaded by coreboot following the boot process.
+
+Stages are assigned a component value of 0x20. When coreboot sees this
+component type, it knows that it should pass the data to a sub-function
+that will process the payload. Furthermore, other run time
+applications such as 'bayou' may easily index all available payloads
+on the system by searching for the payload type.
+
+
+The following is the format of a stage component:
+
+/-----------\
+| Header |
+| Segment 1 |
+| Segment 2 |
+| ... |
+|-----------|
+| Binary |
+| .. |
+\-----------/
+
+The header is as follows:
+
+struct cbfs_payload {
+ struct cbfs_payload_segment segments;
+}
+
+The header contains a number of segments corresponding to the segments
+that need to be loaded for the payload.
+
+The following is the structure of each segment header:
+
+struct cbfs_payload_segment {
+ unsigned int type;
+ unsigned int compression;
+ unsigned int offset;
+ unsigned long long load_addr;
+ unsigned int len;
+ unsigned int mem_len;
+};
+
+'type' is the type of segment, one of the following:
+
+PAYLOAD_SEGMENT_CODE 0x45444F43 The segment contains executable code
+PAYLOAD_SEGMENT_DATA 0x41544144 The segment contains data
+PAYLOAD_SEGMENT_BSS 0x20535342 The memory speicfied by the segment
+ should be zeroed
+PAYLOAD_SEGMENT_PARAMS 0x41524150 The segment contains information for
+ the payload
+PAYLOAD_SEGMENT_ENTRY 0x52544E45 The segment contains the entry point
+ for the payload
+
+'compression' is the compression scheme for the segment. Each segment can
+be independently compressed. There are three compression types defined by
+this version of the standard: none (0x0), lzma (0x1), and nrv2b (0x02),
+though additional types may be added assuming that coreboot understands
+how to handle the scheme.
+
+'offset' is the address of the data within the component, starting from
+the component header.
+
+'load_addr' is a 64 bit value indicating where the segment should be placed
+in memory.
+
+'len' is a 32 bit value indicating the size of the segment within the
+component.
+
+'mem_len' is the size of the data when it is placed into memory.
+
+The data will located immediately following the last segment.
+
+=== Option ROMS ===
+
+The third specified component type will be Option ROMs. Option ROMS will
+have component type '0x30'. They will have no additional header, the
+uncompressed binary data will be located in the data portion of the
+component.
+
+=== NULL ===
+
+There is a 4th component type ,defined as NULL (0xFFFFFFFF). This is
+the "don't care" component type. This can be used when the component
+type is not necessary (such as when the name of the component is unique.
+i.e. option_table). It is recommended that all components be assigned a
+unique type, but NULL can be used when the type does not matter.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+Add interactive mode
+Add script mode (./cbfstool [ROM] -s script)
+Support compression for stages and payloads
+Add nrv2b
--- /dev/null
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+#include "cbfstool.h"
+
+#define MAX_PATH 255
+
+static int add_from_fd(struct rom *rom, const char *name, int type, int fd)
+{
+ unsigned char *buffer = malloc(16 * 1024);
+ unsigned char *ptr = buffer;
+
+ int size = 0;
+ int aloc = 16 * 1024;
+ int remain = 16 * 1024;
+ int ret;
+
+ if (buffer == NULL)
+ return -1;
+
+ while (1) {
+ ret = read(fd, ptr, remain);
+
+ if (ret <= 0)
+ break;
+
+ ptr += ret;
+ remain -= ret;
+ size += ret;
+
+ if (remain == 0) {
+ buffer = realloc(buffer, aloc + 16 * 1024);
+
+ if (buffer == NULL) {
+ ret = -1;
+ break;
+ }
+
+ ptr = buffer + size;
+
+ aloc += (16 * 1024);
+ remain = 16 * 1024;
+ }
+ }
+
+ if (ret == -1 || size == 0) {
+
+ if (buffer != NULL)
+ free(buffer);
+
+ return -1;
+ }
+
+ ret = rom_add(rom, name, buffer, size, type);
+ free(buffer);
+
+ return ret;
+}
+
+int fork_tool_and_add(struct rom *rom, const char *tool, const char *input,
+ const char *name, int type, int argc, char **argv)
+{
+ int output[2];
+ pid_t pid;
+ int ret;
+ int status;
+ char **toolargs;
+ int i;
+
+ /* Create the pipe */
+
+ if (pipe(output)) {
+ ERROR("Couldn't create a pipe: %m\n");
+ return -1;
+ }
+
+ toolargs = (char **)malloc((5 + argc) * sizeof(char *));
+
+ if (toolargs == NULL) {
+ ERROR("Unable to allocate memory: %m\n");
+ return -1;
+ }
+
+ toolargs[0] = (char *)tool;
+
+ /* these are args. So they need a - in front */
+ for (i = 0; i < argc; i++) {
+ /* I wish I had python */
+ char *c = malloc(strlen(argv[i])) + 2;
+ c[0] = '-';
+ strcpy(&c[1], argv[i]);
+ c[strlen(argv[i])+1] = 0;
+ toolargs[1 + i] = c;
+ }
+
+ toolargs[1 + argc] = "-o";
+ toolargs[2 + argc] = "-";
+ toolargs[3 + argc] = (char *)input;
+ toolargs[4 + argc] = NULL;
+
+ pid = fork();
+
+ if (pid == 0) {
+
+ /* Set up stdin/stdout for the child */
+
+ dup2(output[1], STDOUT_FILENO);
+ close(output[0]);
+
+ /* Execute the tool */
+ if (execv(tool, toolargs)) {
+ ERROR("Unable to execute %s: %m\n", tool);
+ exit(-1);
+ }
+
+ exit(0);
+ }
+
+ free(toolargs);
+
+ close(output[1]);
+
+ /* Read from the file */
+ ret = add_from_fd(rom, name, type, output[0]);
+
+ /* Reap the child */
+ waitpid(pid, &status, 0);
+
+ if (WIFSIGNALED(status)) {
+ kill(pid, WTERMSIG(status));
+ ERROR("Error while executing %s\n", tool);
+ return -1;
+ } else if (WEXITSTATUS(status) != 0) {
+ ERROR("Error while executing %s: %d\n", tool,
+ (int)WEXITSTATUS(status));
+ return -1;
+ }
+
+ return ret;
+}
+
+static int add_blob(struct rom *rom, const char *filename,
+ const char *name, int type)
+{
+ void *ptr;
+ struct stat s;
+ int fd, ret;
+
+ if (!strcmp(filename, "-"))
+ return add_from_fd(rom, name, type, 0);
+
+ fd = open(filename, O_RDONLY);
+
+ if (fd == -1) {
+ ERROR("Could not open %s: %m\n", filename);
+ return -1;
+ }
+
+ if (fstat(fd, &s)) {
+ ERROR("Could not stat %s: %m\n", filename);
+ close(fd);
+ return -1;
+ }
+
+ ptr = mmap(0, s.st_size, PROT_READ, MAP_SHARED, fd, 0);
+
+ if (ptr == MAP_FAILED) {
+ ERROR("Unable to map %s: %m\n", filename);
+ close(fd);
+ return -1;
+ }
+
+ ret = rom_add(rom, name, ptr, s.st_size, type);
+
+ munmap(ptr, s.st_size);
+ close(fd);
+
+ return ret;
+}
+
+void add_usage(void)
+{
+ printf("add [FILE] [NAME] [TYPE]\tAdd a component\n");
+}
+
+void add_stage_usage(void)
+{
+ printf("add-stage [FILE] [NAME] [OPTIONS]\tAdd a stage to the ROM\n");
+}
+
+void add_payload_usage(void)
+{
+ printf
+ ("add-payload [FILE] [NAME] [OPTIONS]\tAdd a payload to the ROM\n");
+}
+
+int add_handler(struct rom *rom, int argc, char **argv)
+{
+ unsigned int type = CBFS_COMPONENT_NULL;
+
+ if (argc < 2) {
+ add_usage();
+ return -1;
+ }
+
+ if (!rom_exists(rom)) {
+ ERROR("You need to create the ROM before adding files to it\n");
+ return -1;
+ }
+
+ /* There are two ways to specify the type - a string or a number */
+
+ if (argc == 3) {
+ if (isdigit(*(argv[2])))
+ type = strtoul(argv[2], 0, 0);
+ }
+
+ if (type == CBFS_COMPONENT_NULL)
+ WARN("No file type was given for %s - using default\n",
+ argv[0]);
+
+ return add_blob(rom, argv[0], argv[1], type);
+}
+
+char *find_tool(char *tool)
+{
+ static char toolpath[MAX_PATH];
+ extern char cbfstool_bindir[];
+
+ snprintf(toolpath, MAX_PATH - 1, "tools/%s", tool);
+ if (!access(toolpath, X_OK))
+ return toolpath;
+
+ snprintf(toolpath, MAX_PATH - 1, "%s/tools/%s", cbfstool_bindir, tool);
+
+ if (!access(toolpath, X_OK))
+ return toolpath;
+
+ snprintf(toolpath, MAX_PATH - 1, "%s/%s", cbfstool_bindir, tool);
+
+ if (!access(toolpath, X_OK))
+ return toolpath;
+
+ strncpy(toolpath, tool, MAX_PATH - 1);
+ return toolpath;
+}
+
+/* Invoke the rom-mkpayload utility */
+
+int add_payload_handler(struct rom *rom, int argc, char **argv)
+{
+ if (argc < 2) {
+ add_payload_usage();
+ return -1;
+ }
+
+ /* Make sure the ROM exists */
+
+ if (!rom_exists(rom)) {
+ ERROR("You need to create the ROM before adding files to it\n");
+ return -1;
+ }
+
+ /* Check that the incoming file exists */
+
+ if (access(argv[0], R_OK)) {
+ ERROR("File %s does not exist\n", argv[0]);
+ return -1;
+ }
+
+ return fork_tool_and_add(rom, find_tool("rom-mkpayload"), argv[0],
+ argv[1], CBFS_COMPONENT_PAYLOAD, argc - 2,
+ argc > 2 ? &argv[2] : NULL);
+}
+
+/* Invoke the rom-mkstage utility */
+
+int add_stage_handler(struct rom *rom, int argc, char **argv)
+{
+ if (argc < 2) {
+ add_stage_usage();
+ return -1;
+ }
+
+ /* Make sure the ROM exists */
+
+ if (!rom_exists(rom)) {
+ ERROR("You need to create the ROM before adding files to it\n");
+ return -1;
+ }
+
+ /* Check that the incoming file exists */
+
+ if (access(argv[0], R_OK)) {
+ ERROR("File %s does not exist\n", argv[0]);
+ return -1;
+ }
+
+ return fork_tool_and_add(rom, find_tool("rom-mkstage"), argv[0],
+ argv[1], CBFS_COMPONENT_STAGE, argc - 2,
+ argc > 2 ? &argv[2] : NULL);
+}
--- /dev/null
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "cbfstool.h"
+
+void bootblock_usage(void)
+{
+ printf("bootblock [FILE]\t\tAdd a bootblock to the ROM\n");
+}
+
+int bootblock_handler(struct rom *rom, int argc, char **argv)
+{
+ if (argc < 1) {
+ bootblock_usage();
+ return -1;
+ }
+
+ return add_bootblock(rom, argv[0]);
+}
--- /dev/null
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#ifndef _CBFS_H_
+#define _CBFS_H_
+
+/** These are standard values for the known compression
+ alogrithms that coreboot knows about for stages and
+ payloads. Of course, other LAR users can use whatever
+ values they want, as long as they understand them. */
+
+#define CBFS_COMPRESS_NONE 0
+#define CBFS_COMPRESS_LZMA 1
+#define CBFS_COMPRESS_NRV2B 2
+
+/** These are standard component types for well known
+ components (i.e - those that coreboot needs to consume.
+ Users are welcome to use any other value for their
+ components */
+
+#define CBFS_COMPONENT_STAGE 0x10
+#define CBFS_COMPONENT_PAYLOAD 0x20
+#define CBFS_COMPONENT_OPTIONROM 0x30
+
+#define CBFS_COMPONENT_NULL 0xFFFFFFFF
+
+/** this is the master cbfs header - it need to be
+ located somewhere in the bootblock. Where it
+ actually lives is up to coreboot. A pointer to
+ this header will live at 0xFFFFFFF4, so we can
+ easily find it. */
+
+#define HEADER_MAGIC 0x4F524243
+
+/* this is a version that gives the right answer in any endian-ness */
+#define VERSION1 0x31313131
+
+struct cbfs_header {
+ unsigned int magic;
+ unsigned int version;
+ unsigned int romsize;
+ unsigned int bootblocksize;
+ unsigned int align;
+ unsigned int offset;
+ unsigned int pad[2];
+} __attribute__ ((packed));
+
+/** This is a component header - every entry in the CBFS
+ will have this header.
+
+ This is how the component is arranged in the ROM:
+
+ -------------- <- 0
+ component header
+ -------------- <- sizeof(struct component)
+ component name
+ -------------- <- offset
+ data
+ ...
+ -------------- <- offset + len
+*/
+
+#define COMPONENT_MAGIC "LARCHIVE"
+
+struct cbfs_file {
+ char magic[8];
+ unsigned int len;
+ unsigned int type;
+ unsigned int checksum;
+ unsigned int offset;
+} __attribute__ ((packed));
+
+/*** Component sub-headers ***/
+
+/* Following are component sub-headers for the "standard"
+ component types */
+
+/** This is the sub-header for stage components. Stages are
+ loaded by coreboot during the normal boot process */
+
+struct cbfs_stage {
+ unsigned int compression; /** Compression type */
+ unsigned long long entry; /** entry point */
+ unsigned long long load; /** Where to load in memory */
+ unsigned int len; /** length of data to load */
+ unsigned int memlen; /** total length of object in memory */
+} __attribute__ ((packed));
+
+/** this is the sub-header for payload components. Payloads
+ are loaded by coreboot at the end of the boot process */
+
+struct cbfs_payload_segment {
+ unsigned int type;
+ unsigned int compression;
+ unsigned int offset;
+ unsigned long long load_addr;
+ unsigned int len;
+ unsigned int mem_len;
+} __attribute__ ((packed));
+
+struct cbfs_payload {
+ struct cbfs_payload_segment segments;
+};
+
+#define PAYLOAD_SEGMENT_CODE 0x45444F43
+#define PAYLOAD_SEGMENT_DATA 0x41544144
+#define PAYLOAD_SEGMENT_BSS 0x20535342
+#define PAYLOAD_SEGMENT_PARAMS 0x41524150
+#define PAYLOAD_SEGMENT_ENTRY 0x52544E45
+
+#define CBFS_NAME(_c) (((unsigned char *) (_c)) + sizeof(struct cbfs_file))
+
+#endif
--- /dev/null
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+/* v2 compat: First, assumes a 64K bootblock.
+ * cbfstool coreboot.rom create 0x80000 coreboot.strip
+ * cbfstool coreboot.rom add-payload /tmp/filo.elf payload
+ * cbfstool coreboot.rom print
+ */
+
+
+#include <string.h>
+#include <unistd.h>
+#include <libgen.h>
+#include <sys/mman.h>
+#include "cbfstool.h"
+
+extern int create_handler(struct rom *, int, char **);
+extern int bootblock_handler(struct rom *, int, char **);
+extern int print_handler(struct rom *, int, char **);
+extern int add_handler(struct rom *, int, char **);
+extern int delete_handler(struct rom *, int, char **);
+extern int resize_handler(struct rom *, int, char **);
+extern int add_payload_handler(struct rom *, int, char **);
+extern int add_stage_handler(struct rom *, int, char **);
+
+extern void create_usage(void);
+extern void bootblock_usage(void);
+extern void print_usage(void);
+extern void add_usage(void);
+extern void delete_usage(void);
+extern void resize_usage(void);
+extern void add_payload_usage(void);
+extern void add_stage_usage(void);
+
+struct {
+ char *command;
+ int (*handler) (struct rom *, int, char **);
+ void (*help) (void);
+} commands[] = {
+ {
+ "add", add_handler, add_usage}, {
+ "add-payload", add_payload_handler, add_payload_usage}, {
+ "add-stage", add_stage_handler, add_stage_usage}, {
+ "bootblock", bootblock_handler, bootblock_usage}, {
+ "create", create_handler, create_usage}, {
+ "delete", delete_handler, delete_usage}, {
+ "print", print_handler, print_usage}, {
+ "resize", resize_handler, resize_usage}, {
+"", NULL},};
+
+static struct rom rom;
+
+char cbfstool_bindir[255];
+
+void show_help(void)
+{
+ int i;
+
+ printf("cbfstool [OPTION] [[FILE] [COMMAND] [PARAMETERS]...\n");
+ printf("Apply COMMANDS with PARAMETERS to FILE. If no COMMAND is\n");
+ printf("given, run in interactive mode\n\n");
+ printf("OPTIONs:\n");
+ printf(" -h\t\tDisplay this help message\n");
+ printf(" -C <dir>\tChange to the directory before operating\n\n");
+ printf("COMMANDs:\n");
+
+ for (i = 0; commands[i].handler != NULL; i++)
+ commands[i].help();
+}
+
+int main(int argc, char **argv)
+{
+ char *cdir = NULL;
+ char *rname;
+ char *cmd;
+ int ret = -1, i;
+
+ strncpy(cbfstool_bindir, dirname(argv[0]), 254);
+
+ while (1) {
+ signed ch = getopt(argc, argv, "hC:");
+ if (ch == -1)
+ break;
+ switch (ch) {
+ case 'h':
+ show_help();
+ return -1;
+ case 'C':
+ cdir = optarg;
+ break;
+ }
+ }
+
+ if (optind >= argc) {
+ show_help();
+ return -1;
+ }
+
+ if (cdir != NULL && chdir(cdir)) {
+ ERROR("Unable to switch to %s: %m\n", cdir);
+ return -1;
+ }
+
+ rname = argv[optind];
+ cmd = optind + 1 < argc ? argv[optind + 1] : NULL;
+
+ /* Open the ROM (if it exists) */
+ rom.name = (unsigned char *)strdup(rname);
+
+ if (!access(rname, F_OK)) {
+ if (open_rom(&rom, rname)) {
+ ERROR("Problem while reading the ROM\n");
+ return -1;
+ }
+ }
+
+ if (cmd) {
+ /* Process the incoming comand */
+
+ for (i = 0; commands[i].handler != NULL; i++) {
+ if (!strcmp(commands[i].command, cmd)) {
+ ret = commands[i].handler(&rom,
+ argc - 3, &argv[3]);
+ goto leave;
+ }
+ }
+
+ ERROR("Command %s not valid\n", cmd);
+ } else {
+ printf("Interactive mode not ready yet!\n");
+ }
+
+leave:
+ if (rom.ptr != NULL && rom.ptr != MAP_FAILED)
+ munmap(rom.ptr, rom.size);
+
+ if (rom.fd > 0)
+ close(rom.fd);
+
+ return ret;
+}
--- /dev/null
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#ifndef _ROMTOOL_H_
+#define _ROMTOOL_H_
+
+#include <stdio.h>
+#include <arpa/inet.h>
+#include "cbfs.h"
+
+/* Definitions */
+
+/* Structures */
+
+struct rom {
+ unsigned char *name;
+ unsigned char *ptr;
+
+ int fd;
+ int size;
+ int fssize;
+
+ struct cbfs_header *header;
+};
+
+/* Macros */
+
+#define ROM_OFFSET(_r, _c) ((unsigned int) ((unsigned char *) (_c) - (_r)->ptr))
+
+#define ROM_PTR(_r, _o) ((_r)->ptr + (_o))
+#define ROM_WRITEL(_r, _o, _v) do { *((unsigned int *) ROM_PTR((_r), (_o))) = (_v); } while(0)
+#define ROM_READL(_r, _o) *((unsigned int *) (ROM_PTR((_r), (_o))))
+
+#define ERROR(err, args...) fprintf(stderr, "(cbfstool) E: " err, ##args)
+#define WARN(err, args...) fprintf(stderr, "(cbfstool) W: " err, ##args)
+#define VERBOSE(str, args...) printf(str, ##args)
+
+#define ALIGN(_v, _a) ( ( (_v) + ( (_a) - 1 ) ) & ~( (_a) - 1 ) )
+
+/* Function prototypes */
+
+/* util.c */
+int open_rom(struct rom *rom, const char *filename);
+int create_rom(struct rom *rom, const unsigned char *filename, int size,
+ int bootblocksize, int align);
+int size_and_open(const char *filename, unsigned int *size);
+int copy_from_fd(int fd, void *ptr, int size);
+int get_size(const char *size);
+int add_bootblock(struct rom *rom, const char *filename);
+
+/* fs.c */
+
+struct cbfs_file *rom_find(struct rom *rom, unsigned int offset);
+struct cbfs_file *rom_find_first(struct rom *);
+struct cbfs_file *rom_find_next(struct rom *, struct cbfs_file *);
+int rom_add(struct rom *rom, const char *name, void *, int size, int type);
+int rom_remove(struct rom *rom, const char *name);
+unsigned int rom_used_space(struct rom *rom);
+int rom_exists(struct rom *rom);
+
+#endif
--- /dev/null
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "cbfstool.h"
+
+void create_usage(void)
+{
+ printf("create SIZE BOOTBLOCKSIZE [ALIGN] [BOOTBLOCK]\tCreate a ROM file\n");
+}
+
+int create_handler(struct rom *rom, int argc, char **argv)
+{
+ int align = 16, size;
+ char *bootblock = NULL;
+ int bootblocksize;
+
+ if (argc < 2) {
+ create_usage();
+ return -1;
+ }
+
+ size = get_size(argv[0]);
+
+ bootblocksize = get_size(argv[1]);
+
+ if (argc == 3) {
+ bootblock = argv[2];
+ } else if (argc >= 4) {
+ align = strtoul(argv[2], NULL, 0);
+ bootblock = argv[3];
+ }
+
+ if (size < bootblocksize) {
+ ERROR("Cannot create a rom %d smaller then bootblock size %d\n", size, bootblocksize);
+ return -1;
+ }
+
+ if (align == 0) {
+ ERROR("Cannot create with an align size of 0\n");
+ return -1;
+ }
+
+ if (create_rom(rom, rom->name, size, bootblocksize, align))
+ return -1;
+
+ if (bootblock != NULL)
+ return add_bootblock(rom, bootblock);
+
+ return 0;
+}
--- /dev/null
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "cbfstool.h"
+
+void delete_usage(void)
+{
+ printf("delete [NAME] ...\t\tDelete a component\n");
+}
+
+int delete_handler(struct rom *rom, int argc, char **argv)
+{
+ int i;
+ int ret = 0;
+
+ if (argc < 1) {
+ delete_usage();
+ return -1;
+ }
+
+ for (i = 0; i < argc; i++)
+ ret |= rom_remove(rom, argv[i]);
+
+ return ret;
+}
--- /dev/null
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <string.h>
+#include "cbfstool.h"
+
+struct cbfs_file *rom_find(struct rom *rom, unsigned int offset)
+{
+ while (offset < rom->fssize) {
+ struct cbfs_file *c =
+ (struct cbfs_file *)ROM_PTR(rom, offset);
+
+ if (!strcmp(c->magic, COMPONENT_MAGIC))
+ return c;
+
+ offset += ntohl(rom->header->align);
+ }
+
+ return NULL;
+}
+
+struct cbfs_file *rom_find_first(struct rom *rom)
+{
+ return rom_find(rom, ntohl(rom->header->offset));
+}
+
+struct cbfs_file *rom_find_next(struct rom *rom, struct cbfs_file *prev)
+{
+ unsigned int offset = ROM_OFFSET(rom, prev);
+
+ return rom_find(rom, offset +
+ ALIGN(ntohl(prev->offset) + ntohl(prev->len),
+ ntohl(rom->header->align)));
+}
+
+struct cbfs_file *rom_find_empty(struct rom *rom)
+{
+ unsigned int offset = ntohl(rom->header->offset);
+ unsigned int ret = ntohl(rom->header->offset);
+
+ while (offset < rom->fssize) {
+
+ struct cbfs_file *c =
+ (struct cbfs_file *)ROM_PTR(rom, offset);
+
+ if (!strcmp(c->magic, COMPONENT_MAGIC)) {
+ offset += ALIGN(ntohl(c->offset) + ntohl(c->len),
+ ntohl(rom->header->align));
+
+ ret = offset;
+ } else
+ offset += ntohl(rom->header->align);
+ }
+
+ return (ret < rom->fssize) ?
+ (struct cbfs_file *)ROM_PTR(rom, ret) : NULL;
+}
+
+struct cbfs_file *rom_find_by_name(struct rom *rom, const char *name)
+{
+ struct cbfs_file *c = rom_find_first(rom);
+
+ while (c) {
+ if (!strcmp((char *)CBFS_NAME(c), name))
+ return c;
+
+ c = rom_find_next(rom, c);
+ }
+
+ return NULL;
+}
+
+unsigned int rom_used_space(struct rom *rom)
+{
+ struct cbfs_file *c = rom_find_first(rom);
+ unsigned int ret = 0;
+
+ while (c) {
+ ret = ROM_OFFSET(rom, c) + ntohl(c->offset) + ntohl(c->len);
+ c = rom_find_next(rom, c);
+ }
+
+ return ret;
+}
+
+int rom_remove(struct rom *rom, const char *name)
+{
+ struct cbfs_file *c = rom_find_by_name(rom, name);
+ struct cbfs_file *n;
+ int clear;
+
+ if (c == NULL) {
+ ERROR("Component %s does not exist\n", name);
+ return -1;
+ }
+
+ /* Get the next component - and copy it into the current
+ space */
+
+ n = rom_find_next(rom, c);
+
+ memcpy(c, n, rom->fssize - ROM_OFFSET(rom, n));
+
+ clear = ROM_OFFSET(rom, n) - ROM_OFFSET(rom, c);
+
+ /* Zero the new space */
+ memset(ROM_PTR(rom, rom->fssize - clear), 0, clear);
+ return 0;
+}
+
+int rom_add(struct rom *rom, const char *name, void *buffer, int size, int type)
+{
+ struct cbfs_file *c = rom_find_empty(rom);
+ unsigned int offset;
+ unsigned int csize;
+
+ if (rom_find_by_name(rom, name)) {
+ ERROR("Component %s already exists in this rom\n", name);
+ return -1;
+ }
+
+ if (c == NULL) {
+ ERROR("There is no more room in this ROM\n");
+ return -1;
+ }
+
+ csize = sizeof(struct cbfs_file) + ALIGN(strlen(name), 16) + size;
+
+ offset = ROM_OFFSET(rom, c);
+
+ if (offset + csize >= rom->fssize) {
+ ERROR("There is not enough room in this ROM for this\n");
+ ERROR("component. I need %d bytes, only have %d bytes avail\n",
+ csize, rom->fssize - offset);
+
+ return -1;
+ }
+
+ strcpy(c->magic, COMPONENT_MAGIC);
+
+ csize = sizeof(struct cbfs_file) + ALIGN(strlen(name) + 1, 16);
+
+ c->len = htonl(size);
+ c->offset = htonl(csize);
+ c->type = htonl(type);
+
+ memset(CBFS_NAME(c), 0, ALIGN(strlen(name) + 1, 16));
+ strcpy((char *)CBFS_NAME(c), name);
+
+ memcpy(((unsigned char *)c) + csize, buffer, size);
+ return 0;
+}
--- /dev/null
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <string.h>
+#include "cbfstool.h"
+
+void print_usage(void)
+{
+ printf("print\t\t\t\tShow the contents of the ROM\n");
+}
+
+int print_handler(struct rom *rom, int argc, char **argv)
+{
+ printf("%s: %d kB, bootblocksize %d, romsize %d, offset 0x%x\n", rom->name, rom->size / 1024,
+ ntohl(rom->header->bootblocksize), ntohl(rom->header->romsize), ntohl(rom->header->offset));
+ printf("Alignment: %d bytes\n\n", ntohl(rom->header->align));
+
+ struct cbfs_file *c = rom_find_first(rom);
+
+ printf("%-30s Offset %-12s Size\n", "Name", "Type");
+
+ while (c) {
+ char type[12];
+
+ switch (htonl(c->type)) {
+ case CBFS_COMPONENT_STAGE:
+ strcpy(type, "stage");
+ break;
+ case CBFS_COMPONENT_PAYLOAD:
+ strcpy(type, "payload");
+ break;
+ case CBFS_COMPONENT_OPTIONROM:
+ strcpy(type, "optionrom");
+ break;
+ default:
+ sprintf(type, "0x%8.8x", htonl(c->type));
+ break;
+ }
+
+ printf("%-30s 0x%-8x %-12s %d\n", CBFS_NAME(c),
+ ROM_OFFSET(rom, c), type, htonl(c->len));
+
+ c = rom_find_next(rom, c);
+ }
+
+ return 0;
+}
--- /dev/null
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include "cbfstool.h"
+
+void resize_usage(void)
+{
+ printf("resize [SIZE] [ERASEBLOCK]\tResize the ROM\n");
+}
+
+int resize_handler(struct rom *rom, int argc, char **argv)
+{
+ unsigned int size, align, offset;
+ char null = '\0';
+ int bootblocksize = ntohl(rom->header->bootblocksize);
+
+ if (argc < 1) {
+ resize_usage();
+ return -1;
+ }
+
+ if (rom->fd <= 0) {
+ ERROR("ROM file %s does not exist\n", rom->name);
+ return -1;
+ }
+
+ align = ntohl(rom->header->align);
+ size = get_size(argv[0]);
+
+ if (argc >= 2)
+ align = strtoul(argv[1], NULL, 0);
+
+ if (size == rom->size && align == ntohl(rom->header->align)) {
+ ERROR("New parameters are the same as the old\n");
+ return 0;
+ }
+
+ if (size < bootblocksize) {
+ ERROR("The new size is smaller then the bootblock size\n");
+ return -1;
+ }
+
+ /* if the current ROM is too big for the new size, then complain */
+
+ if (rom_used_space(rom) > size - bootblocksize) {
+ ERROR("The new size is too small for the current ROM\n");
+ return -1;
+ }
+
+ /* Grow the rom if we need to */
+
+ if (size > rom->size) {
+ munmap(rom->ptr, rom->size);
+
+ lseek(rom->fd, size - 1, SEEK_SET);
+ write(rom->fd, &null, 1);
+
+ rom->ptr = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED,
+ rom->fd, 0);
+
+ if (rom->ptr == MAP_FAILED) {
+ ERROR("Unable to grow the ROM\n");
+ return -1;
+ }
+ }
+
+ /* We only have to rewrite the entries if the alignment changed */
+
+ if (align != ntohl(rom->header->align)) {
+ struct cbfs_file *c;
+
+ /* The first entry doesn't have to move */
+
+ c = rom_find(rom, rom->header->offset);
+ offset = rom->header->offset;
+
+ while (c) {
+ struct cbfs_file *n = rom_find_next(rom, c);
+ unsigned int next;
+
+ if (n == NULL)
+ break;
+
+ /* Calculate a new location for the entry */
+ next =
+ ROM_OFFSET(rom,
+ c) + ALIGN(ntohl(c->offset) +
+ ntohl(c->len), align);
+
+ /* Copy the next entry there */
+ memmove(ROM_PTR(rom, next), n,
+ ntohl(n->offset) + ntohl(n->len));
+
+ c = (struct cbfs_file *)ROM_PTR(rom, next);
+
+ /* If the previous header wasn't overwritten by the change,
+ corrupt the header so we don't accidently find it */
+
+ if (ROM_OFFSET(rom, n) >
+ next + ntohl(c->len) + ntohl(c->offset))
+ memset(n->magic, 0, sizeof(n->magic));
+ }
+ }
+
+ /* Copy the bootblock */
+
+ memmove(rom->ptr + size - bootblocksize,
+ rom->ptr + rom->size - bootblocksize, bootblocksize);
+
+ /* Recacluate the location of the header */
+
+ offset = ROM_READL(rom, size - 12);
+
+ rom->header = (struct cbfs_header *)
+ ROM_PTR(rom, size - (0xFFFFFFFF - offset) - 1);
+
+ /* Put the new values in the header */
+ rom->header->romsize = htonl(size);
+ rom->header->align = htonl(align);
+
+ /* Truncate the file if we have to */
+
+ if (size < rom->size) {
+ munmap(rom->ptr, rom->size);
+
+ rom->ptr = NULL;
+
+ if (ftruncate(rom->fd, size)) {
+ ERROR("Unable to truncate the ROM\n");
+ return -1;
+ }
+
+ rom->ptr = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED,
+ rom->fd, 0);
+
+ if (rom->ptr == MAP_FAILED) {
+ ERROR("Unable to truncate the ROM\n");
+ return -1;
+ }
+ }
+
+ rom->size = size;
+ rom->fssize = size - bootblocksize;
+
+ return 0;
+}
--- /dev/null
+tobj ?= $(shell pwd)
+tsrc ?= $(shell pwd)
+
+TARGETS += $(tobj)/rom-mkstage $(tobj)/rom-mkpayload
+
+tools: $(tobj)/rom-mkstage $(tobj)/rom-mkpayload
+
+include $(tsrc)/lzma/Makefile
+
+COMMON = common.o compress.o $(LZMA_OBJ)
+
+$(tobj)/rom-mkstage: $(tobj)/rom-mkstage.o $(patsubst %,$(tobj)/%,$(COMMON))
+ $(CXX) $(CFLAGS) -o $@ $^
+
+$(tobj)/rom-mkpayload: $(tobj)/rom-mkpayload.o $(patsubst %,$(tobj)/%,$(COMMON))
+ $(CXX) $(CFLAGS) -o $@ $^
+
+$(tobj)/%.o: %.c
+ $(CC) $(CFLAGS) -c -o $@ $<
+
+tools-clean:
+ rm -f $(tobj)/rom-mkpayload.o $(tobj)/rom-mkstage.o $(patsubst %,$(tobj)/%,$(COMMON))
+ rm -f $(tobj)/rom-mkpayload $(tobj)/rom-mkstage
+
--- /dev/null
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include "elf.h"
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+#include "common.h"
+
+#define BLOCKSIZE (1024 * 16)
+
+void file_write_from_buffer(int fd, unsigned char *buffer, int size)
+{
+ unsigned char *ptr = buffer;
+
+ while (size) {
+ int ret = write(fd, ptr, size);
+
+ if (ret == -1)
+ break;
+
+ size -= ret;
+ ptr += ret;
+ }
+}
+
+unsigned char *file_read_to_buffer(int fd, int *fsize)
+{
+ unsigned char *buffer = malloc(BLOCKSIZE);
+ unsigned char *ptr = buffer;
+
+ int bsize = BLOCKSIZE;
+ int remain = BLOCKSIZE;
+ int size = 0;
+ int ret;
+
+ if (buffer == NULL)
+ return NULL;
+
+ while (1) {
+ ret = read(fd, ptr, remain);
+
+ if (ret <= 0)
+ break;
+
+ remain -= ret;
+ ptr += ret;
+ size += ret;
+
+ /* Allocate more memory */
+
+ if (remain == 0) {
+ buffer = realloc(buffer, bsize + BLOCKSIZE);
+
+ if (buffer == NULL)
+ return NULL;
+
+ ptr = buffer + size;
+
+ bsize += BLOCKSIZE;
+ remain = BLOCKSIZE;
+ }
+ }
+
+ if (ret == 0) {
+ *fsize = size;
+ return buffer;
+ }
+
+ *fsize = 0;
+ free(buffer);
+ return NULL;
+}
+
+unsigned char *file_read(const char *filename, int *fsize)
+{
+ int fd = open(filename, O_RDONLY);
+ unsigned char *buffer;
+
+ if (fd == -1)
+ return NULL;
+
+ buffer = file_read_to_buffer(fd, fsize);
+ close(fd);
+ return buffer;
+}
+
+void file_write(const char *filename, unsigned char *buffer, int size)
+{
+ int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC,
+ S_IRUSR | S_IWUSR);
+
+ if (fd == -1) {
+ fprintf(stderr, "E: Could not create %s: %m\n", filename);
+ return;
+ }
+
+ file_write_from_buffer(fd, buffer, size);
+ close(fd);
+}
+
+int iself(unsigned char *input)
+{
+ Elf32_Ehdr *ehdr = (Elf32_Ehdr *) input;
+ return !memcmp(ehdr->e_ident, ELFMAG, 4);
+}
--- /dev/null
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#ifndef _COMMON_H_
+#define _COMMON_H_
+
+int iself(unsigned char *input);
+unsigned char *file_read(const char *filename, int *fsize);
+void file_write(const char *filename, unsigned char *buffer, int size);
+unsigned char *file_read_to_buffer(int fd, int *fsize);
+void file_write_from_buffer(int fd, unsigned char *buffer, int size);
+
+/* compress.c */
+
+void lzma_compress(char *in, int in_len, char *out, int *out_len);
+void none_compress(char *in, int in_len, char *out, int *out_len);
+
+#endif
--- /dev/null
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <string.h>
+
+extern void do_lzma_compress(char *in, int in_len, char *out, int *out_len);
+
+void lzma_compress(char *in, int in_len, char *out, int *out_len)
+{
+ do_lzma_compress(in, in_len, out, out_len);
+}
+
+void none_compress(char *in, int in_len, char *out, int *out_len)
+{
+ memcpy(out, in, in_len);
+ *out_len = in_len;
+}
--- /dev/null
+/* This file defines standard ELF types, structures, and macros.
+ Copyright (C) 1995-2003,2004,2005,2006,2007 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library 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.
+
+ The GNU C Library 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 the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#ifndef _ELF_H
+#define _ELF_H 1
+
+#include <stdint.h>
+
+/* Type for a 16-bit quantity. */
+typedef uint16_t Elf32_Half;
+typedef uint16_t Elf64_Half;
+
+/* Types for signed and unsigned 32-bit quantities. */
+typedef uint32_t Elf32_Word;
+typedef int32_t Elf32_Sword;
+typedef uint32_t Elf64_Word;
+typedef int32_t Elf64_Sword;
+
+/* Types for signed and unsigned 64-bit quantities. */
+typedef uint64_t Elf32_Xword;
+typedef int64_t Elf32_Sxword;
+typedef uint64_t Elf64_Xword;
+typedef int64_t Elf64_Sxword;
+
+/* Type of addresses. */
+typedef uint32_t Elf32_Addr;
+typedef uint64_t Elf64_Addr;
+
+/* Type of file offsets. */
+typedef uint32_t Elf32_Off;
+typedef uint64_t Elf64_Off;
+
+/* Type for section indices, which are 16-bit quantities. */
+typedef uint16_t Elf32_Section;
+typedef uint16_t Elf64_Section;
+
+/* Type for version symbol information. */
+typedef Elf32_Half Elf32_Versym;
+typedef Elf64_Half Elf64_Versym;
+
+
+/* The ELF file header. This appears at the start of every ELF file. */
+
+#define EI_NIDENT (16)
+
+typedef struct
+{
+ unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */
+ Elf32_Half e_type; /* Object file type */
+ Elf32_Half e_machine; /* Architecture */
+ Elf32_Word e_version; /* Object file version */
+ Elf32_Addr e_entry; /* Entry point virtual address */
+ Elf32_Off e_phoff; /* Program header table file offset */
+ Elf32_Off e_shoff; /* Section header table file offset */
+ Elf32_Word e_flags; /* Processor-specific flags */
+ Elf32_Half e_ehsize; /* ELF header size in bytes */
+ Elf32_Half e_phentsize; /* Program header table entry size */
+ Elf32_Half e_phnum; /* Program header table entry count */
+ Elf32_Half e_shentsize; /* Section header table entry size */
+ Elf32_Half e_shnum; /* Section header table entry count */
+ Elf32_Half e_shstrndx; /* Section header string table index */
+} Elf32_Ehdr;
+
+typedef struct
+{
+ unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */
+ Elf64_Half e_type; /* Object file type */
+ Elf64_Half e_machine; /* Architecture */
+ Elf64_Word e_version; /* Object file 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; /* Processor-specific flags */
+ Elf64_Half e_ehsize; /* ELF header size in bytes */
+ Elf64_Half e_phentsize; /* Program header table entry size */
+ Elf64_Half e_phnum; /* Program header table entry count */
+ Elf64_Half e_shentsize; /* Section header table entry size */
+ Elf64_Half e_shnum; /* Section header table entry count */
+ Elf64_Half e_shstrndx; /* Section header string table index */
+} Elf64_Ehdr;
+
+/* Fields in the e_ident array. The EI_* macros are indices into the
+ array. The macros under each EI_* macro are the values the byte
+ may have. */
+
+#define EI_MAG0 0 /* File identification byte 0 index */
+#define ELFMAG0 0x7f /* Magic number byte 0 */
+
+#define EI_MAG1 1 /* File identification byte 1 index */
+#define ELFMAG1 'E' /* Magic number byte 1 */
+
+#define EI_MAG2 2 /* File identification byte 2 index */
+#define ELFMAG2 'L' /* Magic number byte 2 */
+
+#define EI_MAG3 3 /* File identification byte 3 index */
+#define ELFMAG3 'F' /* Magic number byte 3 */
+
+/* Conglomeration of the identification bytes, for easy testing as a word. */
+#define ELFMAG "\177ELF"
+#define SELFMAG 4
+
+#define EI_CLASS 4 /* File class byte index */
+#define ELFCLASSNONE 0 /* Invalid class */
+#define ELFCLASS32 1 /* 32-bit objects */
+#define ELFCLASS64 2 /* 64-bit objects */
+#define ELFCLASSNUM 3
+
+#define EI_DATA 5 /* Data encoding byte index */
+#define ELFDATANONE 0 /* Invalid data encoding */
+#define ELFDATA2LSB 1 /* 2's complement, little endian */
+#define ELFDATA2MSB 2 /* 2's complement, big endian */
+#define ELFDATANUM 3
+
+#define EI_VERSION 6 /* File version byte index */
+ /* Value must be EV_CURRENT */
+
+#define EI_OSABI 7 /* OS ABI identification */
+#define ELFOSABI_NONE 0 /* UNIX System V ABI */
+#define ELFOSABI_SYSV 0 /* Alias. */
+#define ELFOSABI_HPUX 1 /* HP-UX */
+#define ELFOSABI_NETBSD 2 /* NetBSD. */
+#define ELFOSABI_LINUX 3 /* Linux. */
+#define ELFOSABI_SOLARIS 6 /* Sun Solaris. */
+#define ELFOSABI_AIX 7 /* IBM AIX. */
+#define ELFOSABI_IRIX 8 /* SGI Irix. */
+#define ELFOSABI_FREEBSD 9 /* FreeBSD. */
+#define ELFOSABI_TRU64 10 /* Compaq TRU64 UNIX. */
+#define ELFOSABI_MODESTO 11 /* Novell Modesto. */
+#define ELFOSABI_OPENBSD 12 /* OpenBSD. */
+#define ELFOSABI_ARM 97 /* ARM */
+#define ELFOSABI_STANDALONE 255 /* Standalone (embedded) application */
+
+#define EI_ABIVERSION 8 /* ABI version */
+
+#define EI_PAD 9 /* Byte index of padding bytes */
+
+/* Legal values for e_type (object file type). */
+
+#define ET_NONE 0 /* No file type */
+#define ET_REL 1 /* Relocatable file */
+#define ET_EXEC 2 /* Executable file */
+#define ET_DYN 3 /* Shared object file */
+#define ET_CORE 4 /* Core file */
+#define ET_NUM 5 /* Number of defined types */
+#define ET_LOOS 0xfe00 /* OS-specific range start */
+#define ET_HIOS 0xfeff /* OS-specific range end */
+#define ET_LOPROC 0xff00 /* Processor-specific range start */
+#define ET_HIPROC 0xffff /* Processor-specific range end */
+
+/* Legal values for e_machine (architecture). */
+
+#define EM_NONE 0 /* No machine */
+#define EM_M32 1 /* AT&T WE 32100 */
+#define EM_SPARC 2 /* SUN SPARC */
+#define EM_386 3 /* Intel 80386 */
+#define EM_68K 4 /* Motorola m68k family */
+#define EM_88K 5 /* Motorola m88k family */
+#define EM_860 7 /* Intel 80860 */
+#define EM_MIPS 8 /* MIPS R3000 big-endian */
+#define EM_S370 9 /* IBM System/370 */
+#define EM_MIPS_RS3_LE 10 /* MIPS R3000 little-endian */
+
+#define EM_PARISC 15 /* HPPA */
+#define EM_VPP500 17 /* Fujitsu VPP500 */
+#define EM_SPARC32PLUS 18 /* Sun's "v8plus" */
+#define EM_960 19 /* Intel 80960 */
+#define EM_PPC 20 /* PowerPC */
+#define EM_PPC64 21 /* PowerPC 64-bit */
+#define EM_S390 22 /* IBM S390 */
+
+#define EM_V800 36 /* NEC V800 series */
+#define EM_FR20 37 /* Fujitsu FR20 */
+#define EM_RH32 38 /* TRW RH-32 */
+#define EM_RCE 39 /* Motorola RCE */
+#define EM_ARM 40 /* ARM */
+#define EM_FAKE_ALPHA 41 /* Digital Alpha */
+#define EM_SH 42 /* Hitachi SH */
+#define EM_SPARCV9 43 /* SPARC v9 64-bit */
+#define EM_TRICORE 44 /* Siemens Tricore */
+#define EM_ARC 45 /* Argonaut RISC Core */
+#define EM_H8_300 46 /* Hitachi H8/300 */
+#define EM_H8_300H 47 /* Hitachi H8/300H */
+#define EM_H8S 48 /* Hitachi H8S */
+#define EM_H8_500 49 /* Hitachi H8/500 */
+#define EM_IA_64 50 /* Intel Merced */
+#define EM_MIPS_X 51 /* Stanford MIPS-X */
+#define EM_COLDFIRE 52 /* Motorola Coldfire */
+#define EM_68HC12 53 /* Motorola M68HC12 */
+#define EM_MMA 54 /* Fujitsu MMA Multimedia Accelerator*/
+#define EM_PCP 55 /* Siemens PCP */
+#define EM_NCPU 56 /* Sony nCPU embeeded RISC */
+#define EM_NDR1 57 /* Denso NDR1 microprocessor */
+#define EM_STARCORE 58 /* Motorola Start*Core processor */
+#define EM_ME16 59 /* Toyota ME16 processor */
+#define EM_ST100 60 /* STMicroelectronic ST100 processor */
+#define EM_TINYJ 61 /* Advanced Logic Corp. Tinyj emb.fam*/
+#define EM_X86_64 62 /* AMD x86-64 architecture */
+#define EM_PDSP 63 /* Sony DSP Processor */
+
+#define EM_FX66 66 /* Siemens FX66 microcontroller */
+#define EM_ST9PLUS 67 /* STMicroelectronics ST9+ 8/16 mc */
+#define EM_ST7 68 /* STmicroelectronics ST7 8 bit mc */
+#define EM_68HC16 69 /* Motorola MC68HC16 microcontroller */
+#define EM_68HC11 70 /* Motorola MC68HC11 microcontroller */
+#define EM_68HC08 71 /* Motorola MC68HC08 microcontroller */
+#define EM_68HC05 72 /* Motorola MC68HC05 microcontroller */
+#define EM_SVX 73 /* Silicon Graphics SVx */
+#define EM_ST19 74 /* STMicroelectronics ST19 8 bit mc */
+#define EM_VAX 75 /* Digital VAX */
+#define EM_CRIS 76 /* Axis Communications 32-bit embedded processor */
+#define EM_JAVELIN 77 /* Infineon Technologies 32-bit embedded processor */
+#define EM_FIREPATH 78 /* Element 14 64-bit DSP Processor */
+#define EM_ZSP 79 /* LSI Logic 16-bit DSP Processor */
+#define EM_MMIX 80 /* Donald Knuth's educational 64-bit processor */
+#define EM_HUANY 81 /* Harvard University machine-independent object files */
+#define EM_PRISM 82 /* SiTera Prism */
+#define EM_AVR 83 /* Atmel AVR 8-bit microcontroller */
+#define EM_FR30 84 /* Fujitsu FR30 */
+#define EM_D10V 85 /* Mitsubishi D10V */
+#define EM_D30V 86 /* Mitsubishi D30V */
+#define EM_V850 87 /* NEC v850 */
+#define EM_M32R 88 /* Mitsubishi M32R */
+#define EM_MN10300 89 /* Matsushita MN10300 */
+#define EM_MN10200 90 /* Matsushita MN10200 */
+#define EM_PJ 91 /* picoJava */
+#define EM_OPENRISC 92 /* OpenRISC 32-bit embedded processor */
+#define EM_ARC_A5 93 /* ARC Cores Tangent-A5 */
+#define EM_XTENSA 94 /* Tensilica Xtensa Architecture */
+#define EM_NUM 95
+
+/* If it is necessary to assign new unofficial EM_* values, please
+ pick large random numbers (0x8523, 0xa7f2, etc.) to minimize the
+ chances of collision with official or non-GNU unofficial values. */
+
+#define EM_ALPHA 0x9026
+
+/* Legal values for e_version (version). */
+
+#define EV_NONE 0 /* Invalid ELF version */
+#define EV_CURRENT 1 /* Current version */
+#define EV_NUM 2
+
+/* Section header. */
+
+typedef struct
+{
+ Elf32_Word sh_name; /* Section name (string tbl index) */
+ Elf32_Word sh_type; /* Section type */
+ Elf32_Word sh_flags; /* Section flags */
+ Elf32_Addr sh_addr; /* Section virtual addr at execution */
+ Elf32_Off sh_offset; /* Section file offset */
+ Elf32_Word sh_size; /* Section size in bytes */
+ Elf32_Word sh_link; /* Link to another section */
+ Elf32_Word sh_info; /* Additional section information */
+ Elf32_Word sh_addralign; /* Section alignment */
+ Elf32_Word sh_entsize; /* Entry size if section holds table */
+} Elf32_Shdr;
+
+typedef struct
+{
+ Elf64_Word sh_name; /* Section name (string tbl index) */
+ Elf64_Word sh_type; /* Section type */
+ Elf64_Xword sh_flags; /* Section flags */
+ Elf64_Addr sh_addr; /* Section virtual addr at execution */
+ Elf64_Off sh_offset; /* Section file offset */
+ Elf64_Xword sh_size; /* Section size in bytes */
+ Elf64_Word sh_link; /* Link to 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;
+
+/* Special section indices. */
+
+#define SHN_UNDEF 0 /* Undefined section */
+#define SHN_LORESERVE 0xff00 /* Start of reserved indices */
+#define SHN_LOPROC 0xff00 /* Start of processor-specific */
+#define SHN_BEFORE 0xff00 /* Order section before all others
+ (Solaris). */
+#define SHN_AFTER 0xff01 /* Order section after all others
+ (Solaris). */
+#define SHN_HIPROC 0xff1f /* End of processor-specific */
+#define SHN_LOOS 0xff20 /* Start of OS-specific */
+#define SHN_HIOS 0xff3f /* End of OS-specific */
+#define SHN_ABS 0xfff1 /* Associated symbol is absolute */
+#define SHN_COMMON 0xfff2 /* Associated symbol is common */
+#define SHN_XINDEX 0xffff /* Index is in extra table. */
+#define SHN_HIRESERVE 0xffff /* End of reserved indices */
+
+/* Legal values for sh_type (section type). */
+
+#define SHT_NULL 0 /* Section header table entry unused */
+#define SHT_PROGBITS 1 /* Program data */
+#define SHT_SYMTAB 2 /* Symbol table */
+#define SHT_STRTAB 3 /* String table */
+#define SHT_RELA 4 /* Relocation entries with addends */
+#define SHT_HASH 5 /* Symbol hash table */
+#define SHT_DYNAMIC 6 /* Dynamic linking information */
+#define SHT_NOTE 7 /* Notes */
+#define SHT_NOBITS 8 /* Program space with no data (bss) */
+#define SHT_REL 9 /* Relocation entries, no addends */
+#define SHT_SHLIB 10 /* Reserved */
+#define SHT_DYNSYM 11 /* Dynamic linker symbol table */
+#define SHT_INIT_ARRAY 14 /* Array of constructors */
+#define SHT_FINI_ARRAY 15 /* Array of destructors */
+#define SHT_PREINIT_ARRAY 16 /* Array of pre-constructors */
+#define SHT_GROUP 17 /* Section group */
+#define SHT_SYMTAB_SHNDX 18 /* Extended section indeces */
+#define SHT_NUM 19 /* Number of defined types. */
+#define SHT_LOOS 0x60000000 /* Start OS-specific. */
+#define SHT_GNU_HASH 0x6ffffff6 /* GNU-style hash table. */
+#define SHT_GNU_LIBLIST 0x6ffffff7 /* Prelink library list */
+#define SHT_CHECKSUM 0x6ffffff8 /* Checksum for DSO content. */
+#define SHT_LOSUNW 0x6ffffffa /* Sun-specific low bound. */
+#define SHT_SUNW_move 0x6ffffffa
+#define SHT_SUNW_COMDAT 0x6ffffffb
+#define SHT_SUNW_syminfo 0x6ffffffc
+#define SHT_GNU_verdef 0x6ffffffd /* Version definition section. */
+#define SHT_GNU_verneed 0x6ffffffe /* Version needs section. */
+#define SHT_GNU_versym 0x6fffffff /* Version symbol table. */
+#define SHT_HISUNW 0x6fffffff /* Sun-specific high bound. */
+#define SHT_HIOS 0x6fffffff /* End OS-specific type */
+#define SHT_LOPROC 0x70000000 /* Start of processor-specific */
+#define SHT_HIPROC 0x7fffffff /* End of processor-specific */
+#define SHT_LOUSER 0x80000000 /* Start of application-specific */
+#define SHT_HIUSER 0x8fffffff /* End of application-specific */
+
+/* Legal values for sh_flags (section flags). */
+
+#define SHF_WRITE (1 << 0) /* Writable */
+#define SHF_ALLOC (1 << 1) /* Occupies memory during execution */
+#define SHF_EXECINSTR (1 << 2) /* Executable */
+#define SHF_MERGE (1 << 4) /* Might be merged */
+#define SHF_STRINGS (1 << 5) /* Contains nul-terminated strings */
+#define SHF_INFO_LINK (1 << 6) /* `sh_info' contains SHT index */
+#define SHF_LINK_ORDER (1 << 7) /* Preserve order after combining */
+#define SHF_OS_NONCONFORMING (1 << 8) /* Non-standard OS specific handling
+ required */
+#define SHF_GROUP (1 << 9) /* Section is member of a group. */
+#define SHF_TLS (1 << 10) /* Section hold thread-local data. */
+#define SHF_MASKOS 0x0ff00000 /* OS-specific. */
+#define SHF_MASKPROC 0xf0000000 /* Processor-specific */
+#define SHF_ORDERED (1 << 30) /* Special ordering requirement
+ (Solaris). */
+#define SHF_EXCLUDE (1 << 31) /* Section is excluded unless
+ referenced or allocated (Solaris).*/
+
+/* Section group handling. */
+#define GRP_COMDAT 0x1 /* Mark group as COMDAT. */
+
+/* Symbol table entry. */
+
+typedef struct
+{
+ Elf32_Word st_name; /* Symbol name (string tbl index) */
+ Elf32_Addr st_value; /* Symbol value */
+ Elf32_Word st_size; /* Symbol size */
+ unsigned char st_info; /* Symbol type and binding */
+ unsigned char st_other; /* Symbol visibility */
+ Elf32_Section st_shndx; /* Section index */
+} Elf32_Sym;
+
+typedef struct
+{
+ Elf64_Word st_name; /* Symbol name (string tbl index) */
+ unsigned char st_info; /* Symbol type and binding */
+ unsigned char st_other; /* Symbol visibility */
+ Elf64_Section st_shndx; /* Section index */
+ Elf64_Addr st_value; /* Symbol value */
+ Elf64_Xword st_size; /* Symbol size */
+} Elf64_Sym;
+
+/* The syminfo section if available contains additional information about
+ every dynamic symbol. */
+
+typedef struct
+{
+ Elf32_Half si_boundto; /* Direct bindings, symbol bound to */
+ Elf32_Half si_flags; /* Per symbol flags */
+} Elf32_Syminfo;
+
+typedef struct
+{
+ Elf64_Half si_boundto; /* Direct bindings, symbol bound to */
+ Elf64_Half si_flags; /* Per symbol flags */
+} Elf64_Syminfo;
+
+/* Possible values for si_boundto. */
+#define SYMINFO_BT_SELF 0xffff /* Symbol bound to self */
+#define SYMINFO_BT_PARENT 0xfffe /* Symbol bound to parent */
+#define SYMINFO_BT_LOWRESERVE 0xff00 /* Beginning of reserved entries */
+
+/* Possible bitmasks for si_flags. */
+#define SYMINFO_FLG_DIRECT 0x0001 /* Direct bound symbol */
+#define SYMINFO_FLG_PASSTHRU 0x0002 /* Pass-thru symbol for translator */
+#define SYMINFO_FLG_COPY 0x0004 /* Symbol is a copy-reloc */
+#define SYMINFO_FLG_LAZYLOAD 0x0008 /* Symbol bound to object to be lazy
+ loaded */
+/* Syminfo version values. */
+#define SYMINFO_NONE 0
+#define SYMINFO_CURRENT 1
+#define SYMINFO_NUM 2
+
+
+/* How to extract and insert information held in the st_info field. */
+
+#define ELF32_ST_BIND(val) (((unsigned char) (val)) >> 4)
+#define ELF32_ST_TYPE(val) ((val) & 0xf)
+#define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
+
+/* Both Elf32_Sym and Elf64_Sym use the same one-byte st_info field. */
+#define ELF64_ST_BIND(val) ELF32_ST_BIND (val)
+#define ELF64_ST_TYPE(val) ELF32_ST_TYPE (val)
+#define ELF64_ST_INFO(bind, type) ELF32_ST_INFO ((bind), (type))
+
+/* Legal values for ST_BIND subfield of st_info (symbol binding). */
+
+#define STB_LOCAL 0 /* Local symbol */
+#define STB_GLOBAL 1 /* Global symbol */
+#define STB_WEAK 2 /* Weak symbol */
+#define STB_NUM 3 /* Number of defined types. */
+#define STB_LOOS 10 /* Start of OS-specific */
+#define STB_HIOS 12 /* End of OS-specific */
+#define STB_LOPROC 13 /* Start of processor-specific */
+#define STB_HIPROC 15 /* End of processor-specific */
+
+/* Legal values for ST_TYPE subfield of st_info (symbol type). */
+
+#define STT_NOTYPE 0 /* Symbol type is unspecified */
+#define STT_OBJECT 1 /* Symbol is a data object */
+#define STT_FUNC 2 /* Symbol is a code object */
+#define STT_SECTION 3 /* Symbol associated with a section */
+#define STT_FILE 4 /* Symbol's name is file name */
+#define STT_COMMON 5 /* Symbol is a common data object */
+#define STT_TLS 6 /* Symbol is thread-local data object*/
+#define STT_NUM 7 /* Number of defined types. */
+#define STT_LOOS 10 /* Start of OS-specific */
+#define STT_HIOS 12 /* End of OS-specific */
+#define STT_LOPROC 13 /* Start of processor-specific */
+#define STT_HIPROC 15 /* End of processor-specific */
+
+
+/* Symbol table indices are found in the hash buckets and chain table
+ of a symbol hash table section. This special index value indicates
+ the end of a chain, meaning no further symbols are found in that bucket. */
+
+#define STN_UNDEF 0 /* End of a chain. */
+
+
+/* How to extract and insert information held in the st_other field. */
+
+#define ELF32_ST_VISIBILITY(o) ((o) & 0x03)
+
+/* For ELF64 the definitions are the same. */
+#define ELF64_ST_VISIBILITY(o) ELF32_ST_VISIBILITY (o)
+
+/* Symbol visibility specification encoded in the st_other field. */
+#define STV_DEFAULT 0 /* Default symbol visibility rules */
+#define STV_INTERNAL 1 /* Processor specific hidden class */
+#define STV_HIDDEN 2 /* Sym unavailable in other modules */
+#define STV_PROTECTED 3 /* Not preemptible, not exported */
+
+
+/* Relocation table entry without addend (in section of type SHT_REL). */
+
+typedef struct
+{
+ Elf32_Addr r_offset; /* Address */
+ Elf32_Word r_info; /* Relocation type and symbol index */
+} Elf32_Rel;
+
+/* I have seen two different definitions of the Elf64_Rel and
+ Elf64_Rela structures, so we'll leave them out until Novell (or
+ whoever) gets their act together. */
+/* The following, at least, is used on Sparc v9, MIPS, and Alpha. */
+
+typedef struct
+{
+ Elf64_Addr r_offset; /* Address */
+ Elf64_Xword r_info; /* Relocation type and symbol index */
+} Elf64_Rel;
+
+/* Relocation table entry with addend (in section of type SHT_RELA). */
+
+typedef struct
+{
+ Elf32_Addr r_offset; /* Address */
+ Elf32_Word r_info; /* Relocation type and symbol index */
+ Elf32_Sword r_addend; /* Addend */
+} Elf32_Rela;
+
+typedef struct
+{
+ Elf64_Addr r_offset; /* Address */
+ Elf64_Xword r_info; /* Relocation type and symbol index */
+ Elf64_Sxword r_addend; /* Addend */
+} Elf64_Rela;
+
+/* How to extract and insert information held in the r_info field. */
+
+#define ELF32_R_SYM(val) ((val) >> 8)
+#define ELF32_R_TYPE(val) ((val) & 0xff)
+#define ELF32_R_INFO(sym, type) (((sym) << 8) + ((type) & 0xff))
+
+#define ELF64_R_SYM(i) ((i) >> 32)
+#define ELF64_R_TYPE(i) ((i) & 0xffffffff)
+#define ELF64_R_INFO(sym,type) ((((Elf64_Xword) (sym)) << 32) + (type))
+
+/* Program segment header. */
+
+typedef struct
+{
+ Elf32_Word p_type; /* Segment type */
+ Elf32_Off p_offset; /* Segment file offset */
+ Elf32_Addr p_vaddr; /* Segment virtual address */
+ Elf32_Addr p_paddr; /* Segment physical address */
+ Elf32_Word p_filesz; /* Segment size in file */
+ Elf32_Word p_memsz; /* Segment size in memory */
+ Elf32_Word p_flags; /* Segment flags */
+ Elf32_Word p_align; /* Segment alignment */
+} Elf32_Phdr;
+
+typedef struct
+{
+ Elf64_Word p_type; /* Segment type */
+ Elf64_Word p_flags; /* Segment 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 */
+} Elf64_Phdr;
+
+/* Legal values for p_type (segment type). */
+
+#define PT_NULL 0 /* Program header table entry unused */
+#define PT_LOAD 1 /* Loadable program segment */
+#define PT_DYNAMIC 2 /* Dynamic linking information */
+#define PT_INTERP 3 /* Program interpreter */
+#define PT_NOTE 4 /* Auxiliary information */
+#define PT_SHLIB 5 /* Reserved */
+#define PT_PHDR 6 /* Entry for header table itself */
+#define PT_TLS 7 /* Thread-local storage segment */
+#define PT_NUM 8 /* Number of defined types */
+#define PT_LOOS 0x60000000 /* Start of OS-specific */
+#define PT_GNU_EH_FRAME 0x6474e550 /* GCC .eh_frame_hdr segment */
+#define PT_GNU_STACK 0x6474e551 /* Indicates stack executability */
+#define PT_GNU_RELRO 0x6474e552 /* Read-only after relocation */
+#define PT_LOSUNW 0x6ffffffa
+#define PT_SUNWBSS 0x6ffffffa /* Sun Specific segment */
+#define PT_SUNWSTACK 0x6ffffffb /* Stack segment */
+#define PT_HISUNW 0x6fffffff
+#define PT_HIOS 0x6fffffff /* End of OS-specific */
+#define PT_LOPROC 0x70000000 /* Start of processor-specific */
+#define PT_HIPROC 0x7fffffff /* End of processor-specific */
+
+/* Legal values for p_flags (segment flags). */
+
+#define PF_X (1 << 0) /* Segment is executable */
+#define PF_W (1 << 1) /* Segment is writable */
+#define PF_R (1 << 2) /* Segment is readable */
+#define PF_MASKOS 0x0ff00000 /* OS-specific */
+#define PF_MASKPROC 0xf0000000 /* Processor-specific */
+
+/* Legal values for note segment descriptor types for core files. */
+
+#define NT_PRSTATUS 1 /* Contains copy of prstatus struct */
+#define NT_FPREGSET 2 /* Contains copy of fpregset struct */
+#define NT_PRPSINFO 3 /* Contains copy of prpsinfo struct */
+#define NT_PRXREG 4 /* Contains copy of prxregset struct */
+#define NT_TASKSTRUCT 4 /* Contains copy of task structure */
+#define NT_PLATFORM 5 /* String from sysinfo(SI_PLATFORM) */
+#define NT_AUXV 6 /* Contains copy of auxv array */
+#define NT_GWINDOWS 7 /* Contains copy of gwindows struct */
+#define NT_ASRS 8 /* Contains copy of asrset struct */
+#define NT_PSTATUS 10 /* Contains copy of pstatus struct */
+#define NT_PSINFO 13 /* Contains copy of psinfo struct */
+#define NT_PRCRED 14 /* Contains copy of prcred struct */
+#define NT_UTSNAME 15 /* Contains copy of utsname struct */
+#define NT_LWPSTATUS 16 /* Contains copy of lwpstatus struct */
+#define NT_LWPSINFO 17 /* Contains copy of lwpinfo struct */
+#define NT_PRFPXREG 20 /* Contains copy of fprxregset struct */
+#define NT_PRXFPREG 0x46e62b7f /* Contains copy of user_fxsr_struct */
+
+/* Legal values for the note segment descriptor types for object files. */
+
+#define NT_VERSION 1 /* Contains a version string. */
+
+
+/* Dynamic section entry. */
+
+typedef struct
+{
+ Elf32_Sword d_tag; /* Dynamic entry type */
+ union
+ {
+ Elf32_Word d_val; /* Integer value */
+ Elf32_Addr d_ptr; /* Address value */
+ } d_un;
+} Elf32_Dyn;
+
+typedef struct
+{
+ Elf64_Sxword d_tag; /* Dynamic entry type */
+ union
+ {
+ Elf64_Xword d_val; /* Integer value */
+ Elf64_Addr d_ptr; /* Address value */
+ } d_un;
+} Elf64_Dyn;
+
+/* Legal values for d_tag (dynamic entry type). */
+
+#define DT_NULL 0 /* Marks end of dynamic section */
+#define DT_NEEDED 1 /* Name of needed library */
+#define DT_PLTRELSZ 2 /* Size in bytes of PLT relocs */
+#define DT_PLTGOT 3 /* Processor defined value */
+#define DT_HASH 4 /* Address of symbol hash table */
+#define DT_STRTAB 5 /* Address of string table */
+#define DT_SYMTAB 6 /* Address of symbol table */
+#define DT_RELA 7 /* Address of Rela relocs */
+#define DT_RELASZ 8 /* Total size of Rela relocs */
+#define DT_RELAENT 9 /* Size of one Rela reloc */
+#define DT_STRSZ 10 /* Size of string table */
+#define DT_SYMENT 11 /* Size of one symbol table entry */
+#define DT_INIT 12 /* Address of init function */
+#define DT_FINI 13 /* Address of termination function */
+#define DT_SONAME 14 /* Name of shared object */
+#define DT_RPATH 15 /* Library search path (deprecated) */
+#define DT_SYMBOLIC 16 /* Start symbol search here */
+#define DT_REL 17 /* Address of Rel relocs */
+#define DT_RELSZ 18 /* Total size of Rel relocs */
+#define DT_RELENT 19 /* Size of one Rel reloc */
+#define DT_PLTREL 20 /* Type of reloc in PLT */
+#define DT_DEBUG 21 /* For debugging; unspecified */
+#define DT_TEXTREL 22 /* Reloc might modify .text */
+#define DT_JMPREL 23 /* Address of PLT relocs */
+#define DT_BIND_NOW 24 /* Process relocations of object */
+#define DT_INIT_ARRAY 25 /* Array with addresses of init fct */
+#define DT_FINI_ARRAY 26 /* Array with addresses of fini fct */
+#define DT_INIT_ARRAYSZ 27 /* Size in bytes of DT_INIT_ARRAY */
+#define DT_FINI_ARRAYSZ 28 /* Size in bytes of DT_FINI_ARRAY */
+#define DT_RUNPATH 29 /* Library search path */
+#define DT_FLAGS 30 /* Flags for the object being loaded */
+#define DT_ENCODING 32 /* Start of encoded range */
+#define DT_PREINIT_ARRAY 32 /* Array with addresses of preinit fct*/
+#define DT_PREINIT_ARRAYSZ 33 /* size in bytes of DT_PREINIT_ARRAY */
+#define DT_NUM 34 /* Number used */
+#define DT_LOOS 0x6000000d /* Start of OS-specific */
+#define DT_HIOS 0x6ffff000 /* End of OS-specific */
+#define DT_LOPROC 0x70000000 /* Start of processor-specific */
+#define DT_HIPROC 0x7fffffff /* End of processor-specific */
+#define DT_PROCNUM DT_MIPS_NUM /* Most used by any processor */
+
+/* DT_* entries which fall between DT_VALRNGHI & DT_VALRNGLO use the
+ Dyn.d_un.d_val field of the Elf*_Dyn structure. This follows Sun's
+ approach. */
+#define DT_VALRNGLO 0x6ffffd00
+#define DT_GNU_PRELINKED 0x6ffffdf5 /* Prelinking timestamp */
+#define DT_GNU_CONFLICTSZ 0x6ffffdf6 /* Size of conflict section */
+#define DT_GNU_LIBLISTSZ 0x6ffffdf7 /* Size of library list */
+#define DT_CHECKSUM 0x6ffffdf8
+#define DT_PLTPADSZ 0x6ffffdf9
+#define DT_MOVEENT 0x6ffffdfa
+#define DT_MOVESZ 0x6ffffdfb
+#define DT_FEATURE_1 0x6ffffdfc /* Feature selection (DTF_*). */
+#define DT_POSFLAG_1 0x6ffffdfd /* Flags for DT_* entries, effecting
+ the following DT_* entry. */
+#define DT_SYMINSZ 0x6ffffdfe /* Size of syminfo table (in bytes) */
+#define DT_SYMINENT 0x6ffffdff /* Entry size of syminfo */
+#define DT_VALRNGHI 0x6ffffdff
+#define DT_VALTAGIDX(tag) (DT_VALRNGHI - (tag)) /* Reverse order! */
+#define DT_VALNUM 12
+
+/* DT_* entries which fall between DT_ADDRRNGHI & DT_ADDRRNGLO use the
+ Dyn.d_un.d_ptr field of the Elf*_Dyn structure.
+
+ If any adjustment is made to the ELF object after it has been
+ built these entries will need to be adjusted. */
+#define DT_ADDRRNGLO 0x6ffffe00
+#define DT_GNU_HASH 0x6ffffef5 /* GNU-style hash table. */
+#define DT_TLSDESC_PLT 0x6ffffef6
+#define DT_TLSDESC_GOT 0x6ffffef7
+#define DT_GNU_CONFLICT 0x6ffffef8 /* Start of conflict section */
+#define DT_GNU_LIBLIST 0x6ffffef9 /* Library list */
+#define DT_CONFIG 0x6ffffefa /* Configuration information. */
+#define DT_DEPAUDIT 0x6ffffefb /* Dependency auditing. */
+#define DT_AUDIT 0x6ffffefc /* Object auditing. */
+#define DT_PLTPAD 0x6ffffefd /* PLT padding. */
+#define DT_MOVETAB 0x6ffffefe /* Move table. */
+#define DT_SYMINFO 0x6ffffeff /* Syminfo table. */
+#define DT_ADDRRNGHI 0x6ffffeff
+#define DT_ADDRTAGIDX(tag) (DT_ADDRRNGHI - (tag)) /* Reverse order! */
+#define DT_ADDRNUM 11
+
+/* The versioning entry types. The next are defined as part of the
+ GNU extension. */
+#define DT_VERSYM 0x6ffffff0
+
+#define DT_RELACOUNT 0x6ffffff9
+#define DT_RELCOUNT 0x6ffffffa
+
+/* These were chosen by Sun. */
+#define DT_FLAGS_1 0x6ffffffb /* State flags, see DF_1_* below. */
+#define DT_VERDEF 0x6ffffffc /* Address of version definition
+ table */
+#define DT_VERDEFNUM 0x6ffffffd /* Number of version definitions */
+#define DT_VERNEED 0x6ffffffe /* Address of table with needed
+ versions */
+#define DT_VERNEEDNUM 0x6fffffff /* Number of needed versions */
+#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
+#define DT_VERSIONTAGNUM 16
+
+/* Sun added these machine-independent extensions in the "processor-specific"
+ range. Be compatible. */
+#define DT_AUXILIARY 0x7ffffffd /* Shared object to load before self */
+#define DT_FILTER 0x7fffffff /* Shared object to get values from */
+#define DT_EXTRATAGIDX(tag) ((Elf32_Word)-((Elf32_Sword) (tag) <<1>>1)-1)
+#define DT_EXTRANUM 3
+
+/* Values of `d_un.d_val' in the DT_FLAGS entry. */
+#define DF_ORIGIN 0x00000001 /* Object may use DF_ORIGIN */
+#define DF_SYMBOLIC 0x00000002 /* Symbol resolutions starts here */
+#define DF_TEXTREL 0x00000004 /* Object contains text relocations */
+#define DF_BIND_NOW 0x00000008 /* No lazy binding for this object */
+#define DF_STATIC_TLS 0x00000010 /* Module uses the static TLS model */
+
+/* State flags selectable in the `d_un.d_val' element of the DT_FLAGS_1
+ entry in the dynamic section. */
+#define DF_1_NOW 0x00000001 /* Set RTLD_NOW for this object. */
+#define DF_1_GLOBAL 0x00000002 /* Set RTLD_GLOBAL for this object. */
+#define DF_1_GROUP 0x00000004 /* Set RTLD_GROUP for this object. */
+#define DF_1_NODELETE 0x00000008 /* Set RTLD_NODELETE for this object.*/
+#define DF_1_LOADFLTR 0x00000010 /* Trigger filtee loading at runtime.*/
+#define DF_1_INITFIRST 0x00000020 /* Set RTLD_INITFIRST for this object*/
+#define DF_1_NOOPEN 0x00000040 /* Set RTLD_NOOPEN for this object. */
+#define DF_1_ORIGIN 0x00000080 /* $ORIGIN must be handled. */
+#define DF_1_DIRECT 0x00000100 /* Direct binding enabled. */
+#define DF_1_TRANS 0x00000200
+#define DF_1_INTERPOSE 0x00000400 /* Object is used to interpose. */
+#define DF_1_NODEFLIB 0x00000800 /* Ignore default lib search path. */
+#define DF_1_NODUMP 0x00001000 /* Object can't be dldump'ed. */
+#define DF_1_CONFALT 0x00002000 /* Configuration alternative created.*/
+#define DF_1_ENDFILTEE 0x00004000 /* Filtee terminates filters search. */
+#define DF_1_DISPRELDNE 0x00008000 /* Disp reloc applied at build time. */
+#define DF_1_DISPRELPND 0x00010000 /* Disp reloc applied at run-time. */
+
+/* Flags for the feature selection in DT_FEATURE_1. */
+#define DTF_1_PARINIT 0x00000001
+#define DTF_1_CONFEXP 0x00000002
+
+/* Flags in the DT_POSFLAG_1 entry effecting only the next DT_* entry. */
+#define DF_P1_LAZYLOAD 0x00000001 /* Lazyload following object. */
+#define DF_P1_GROUPPERM 0x00000002 /* Symbols from next object are not
+ generally available. */
+
+/* Version definition sections. */
+
+typedef struct
+{
+ Elf32_Half vd_version; /* Version revision */
+ Elf32_Half vd_flags; /* Version information */
+ Elf32_Half vd_ndx; /* Version Index */
+ Elf32_Half vd_cnt; /* Number of associated aux entries */
+ Elf32_Word vd_hash; /* Version name hash value */
+ Elf32_Word vd_aux; /* Offset in bytes to verdaux array */
+ Elf32_Word vd_next; /* Offset in bytes to next verdef
+ entry */
+} Elf32_Verdef;
+
+typedef struct
+{
+ Elf64_Half vd_version; /* Version revision */
+ Elf64_Half vd_flags; /* Version information */
+ Elf64_Half vd_ndx; /* Version Index */
+ Elf64_Half vd_cnt; /* Number of associated aux entries */
+ Elf64_Word vd_hash; /* Version name hash value */
+ Elf64_Word vd_aux; /* Offset in bytes to verdaux array */
+ Elf64_Word vd_next; /* Offset in bytes to next verdef
+ entry */
+} Elf64_Verdef;
+
+
+/* Legal values for vd_version (version revision). */
+#define VER_DEF_NONE 0 /* No version */
+#define VER_DEF_CURRENT 1 /* Current version */
+#define VER_DEF_NUM 2 /* Given version number */
+
+/* Legal values for vd_flags (version information flags). */
+#define VER_FLG_BASE 0x1 /* Version definition of file itself */
+#define VER_FLG_WEAK 0x2 /* Weak version identifier */
+
+/* Versym symbol index values. */
+#define VER_NDX_LOCAL 0 /* Symbol is local. */
+#define VER_NDX_GLOBAL 1 /* Symbol is global. */
+#define VER_NDX_LORESERVE 0xff00 /* Beginning of reserved entries. */
+#define VER_NDX_ELIMINATE 0xff01 /* Symbol is to be eliminated. */
+
+/* Auxialiary version information. */
+
+typedef struct
+{
+ Elf32_Word vda_name; /* Version or dependency names */
+ Elf32_Word vda_next; /* Offset in bytes to next verdaux
+ entry */
+} Elf32_Verdaux;
+
+typedef struct
+{
+ Elf64_Word vda_name; /* Version or dependency names */
+ Elf64_Word vda_next; /* Offset in bytes to next verdaux
+ entry */
+} Elf64_Verdaux;
+
+
+/* Version dependency section. */
+
+typedef struct
+{
+ Elf32_Half vn_version; /* Version of structure */
+ Elf32_Half vn_cnt; /* Number of associated aux entries */
+ Elf32_Word vn_file; /* Offset of filename for this
+ dependency */
+ Elf32_Word vn_aux; /* Offset in bytes to vernaux array */
+ Elf32_Word vn_next; /* Offset in bytes to next verneed
+ entry */
+} Elf32_Verneed;
+
+typedef struct
+{
+ Elf64_Half vn_version; /* Version of structure */
+ Elf64_Half vn_cnt; /* Number of associated aux entries */
+ Elf64_Word vn_file; /* Offset of filename for this
+ dependency */
+ Elf64_Word vn_aux; /* Offset in bytes to vernaux array */
+ Elf64_Word vn_next; /* Offset in bytes to next verneed
+ entry */
+} Elf64_Verneed;
+
+
+/* Legal values for vn_version (version revision). */
+#define VER_NEED_NONE 0 /* No version */
+#define VER_NEED_CURRENT 1 /* Current version */
+#define VER_NEED_NUM 2 /* Given version number */
+
+/* Auxiliary needed version information. */
+
+typedef struct
+{
+ Elf32_Word vna_hash; /* Hash value of dependency name */
+ Elf32_Half vna_flags; /* Dependency specific information */
+ Elf32_Half vna_other; /* Unused */
+ Elf32_Word vna_name; /* Dependency name string offset */
+ Elf32_Word vna_next; /* Offset in bytes to next vernaux
+ entry */
+} Elf32_Vernaux;
+
+typedef struct
+{
+ Elf64_Word vna_hash; /* Hash value of dependency name */
+ Elf64_Half vna_flags; /* Dependency specific information */
+ Elf64_Half vna_other; /* Unused */
+ Elf64_Word vna_name; /* Dependency name string offset */
+ Elf64_Word vna_next; /* Offset in bytes to next vernaux
+ entry */
+} Elf64_Vernaux;
+
+
+/* Legal values for vna_flags. */
+#define VER_FLG_WEAK 0x2 /* Weak version identifier */
+
+
+/* Auxiliary vector. */
+
+/* This vector is normally only used by the program interpreter. The
+ usual definition in an ABI supplement uses the name auxv_t. The
+ vector is not usually defined in a standard <elf.h> file, but it
+ can't hurt. We rename it to avoid conflicts. The sizes of these
+ types are an arrangement between the exec server and the program
+ interpreter, so we don't fully specify them here. */
+
+typedef struct
+{
+ uint32_t a_type; /* Entry type */
+ union
+ {
+ uint32_t a_val; /* Integer value */
+ /* We use to have pointer elements added here. We cannot do that,
+ though, since it does not work when using 32-bit definitions
+ on 64-bit platforms and vice versa. */
+ } a_un;
+} Elf32_auxv_t;
+
+typedef struct
+{
+ uint64_t a_type; /* Entry type */
+ union
+ {
+ uint64_t a_val; /* Integer value */
+ /* We use to have pointer elements added here. We cannot do that,
+ though, since it does not work when using 32-bit definitions
+ on 64-bit platforms and vice versa. */
+ } a_un;
+} Elf64_auxv_t;
+
+/* Legal values for a_type (entry type). */
+
+#define AT_NULL 0 /* End of vector */
+#define AT_IGNORE 1 /* Entry should be ignored */
+#define AT_EXECFD 2 /* File descriptor of program */
+#define AT_PHDR 3 /* Program headers for program */
+#define AT_PHENT 4 /* Size of program header entry */
+#define AT_PHNUM 5 /* Number of program headers */
+#define AT_PAGESZ 6 /* System page size */
+#define AT_BASE 7 /* Base address of interpreter */
+#define AT_FLAGS 8 /* Flags */
+#define AT_ENTRY 9 /* Entry point of program */
+#define AT_NOTELF 10 /* Program is not ELF */
+#define AT_UID 11 /* Real uid */
+#define AT_EUID 12 /* Effective uid */
+#define AT_GID 13 /* Real gid */
+#define AT_EGID 14 /* Effective gid */
+#define AT_CLKTCK 17 /* Frequency of times() */
+
+/* Some more special a_type values describing the hardware. */
+#define AT_PLATFORM 15 /* String identifying platform. */
+#define AT_HWCAP 16 /* Machine dependent hints about
+ processor capabilities. */
+
+/* This entry gives some information about the FPU initialization
+ performed by the kernel. */
+#define AT_FPUCW 18 /* Used FPU control word. */
+
+/* Cache block sizes. */
+#define AT_DCACHEBSIZE 19 /* Data cache block size. */
+#define AT_ICACHEBSIZE 20 /* Instruction cache block size. */
+#define AT_UCACHEBSIZE 21 /* Unified cache block size. */
+
+/* A special ignored value for PPC, used by the kernel to control the
+ interpretation of the AUXV. Must be > 16. */
+#define AT_IGNOREPPC 22 /* Entry should be ignored. */
+
+#define AT_SECURE 23 /* Boolean, was exec setuid-like? */
+
+/* Pointer to the global system page used for system calls and other
+ nice things. */
+#define AT_SYSINFO 32
+#define AT_SYSINFO_EHDR 33
+
+/* Shapes of the caches. Bits 0-3 contains associativity; bits 4-7 contains
+ log2 of line size; mask those to get cache size. */
+#define AT_L1I_CACHESHAPE 34
+#define AT_L1D_CACHESHAPE 35
+#define AT_L2_CACHESHAPE 36
+#define AT_L3_CACHESHAPE 37
+
+/* Note section contents. Each entry in the note section begins with
+ a header of a fixed form. */
+
+typedef struct
+{
+ Elf32_Word n_namesz; /* Length of the note's name. */
+ Elf32_Word n_descsz; /* Length of the note's descriptor. */
+ Elf32_Word n_type; /* Type of the note. */
+} Elf32_Nhdr;
+
+typedef struct
+{
+ Elf64_Word n_namesz; /* Length of the note's name. */
+ Elf64_Word n_descsz; /* Length of the note's descriptor. */
+ Elf64_Word n_type; /* Type of the note. */
+} Elf64_Nhdr;
+
+/* Known names of notes. */
+
+/* Solaris entries in the note section have this name. */
+#define ELF_NOTE_SOLARIS "SUNW Solaris"
+
+/* Note entries for GNU systems have this name. */
+#define ELF_NOTE_GNU "GNU"
+
+
+/* Defined types of notes for Solaris. */
+
+/* Value of descriptor (one word) is desired pagesize for the binary. */
+#define ELF_NOTE_PAGESIZE_HINT 1
+
+
+/* Defined note types for GNU systems. */
+
+/* ABI information. The descriptor consists of words:
+ word 0: OS descriptor
+ word 1: major version of the ABI
+ word 2: minor version of the ABI
+ word 3: subminor version of the ABI
+*/
+#define NT_GNU_ABI_TAG 1
+#define ELF_NOTE_ABI NT_GNU_ABI_TAG /* Old name. */
+
+/* Known OSes. These values can appear in word 0 of an
+ NT_GNU_ABI_TAG note section entry. */
+#define ELF_NOTE_OS_LINUX 0
+#define ELF_NOTE_OS_GNU 1
+#define ELF_NOTE_OS_SOLARIS2 2
+#define ELF_NOTE_OS_FREEBSD 3
+
+/* Synthetic hwcap information. The descriptor begins with two words:
+ word 0: number of entries
+ word 1: bitmask of enabled entries
+ Then follow variable-length entries, one byte followed by a
+ '\0'-terminated hwcap name string. The byte gives the bit
+ number to test if enabled, (1U << bit) & bitmask. */
+#define NT_GNU_HWCAP 2
+
+/* Build ID bits as generated by ld --build-id.
+ The descriptor consists of any nonzero number of bytes. */
+#define NT_GNU_BUILD_ID 3
+
+
+/* Move records. */
+typedef struct
+{
+ Elf32_Xword m_value; /* Symbol value. */
+ Elf32_Word m_info; /* Size and index. */
+ Elf32_Word m_poffset; /* Symbol offset. */
+ Elf32_Half m_repeat; /* Repeat count. */
+ Elf32_Half m_stride; /* Stride info. */
+} Elf32_Move;
+
+typedef struct
+{
+ Elf64_Xword m_value; /* Symbol value. */
+ Elf64_Xword m_info; /* Size and index. */
+ Elf64_Xword m_poffset; /* Symbol offset. */
+ Elf64_Half m_repeat; /* Repeat count. */
+ Elf64_Half m_stride; /* Stride info. */
+} Elf64_Move;
+
+/* Macro to construct move records. */
+#define ELF32_M_SYM(info) ((info) >> 8)
+#define ELF32_M_SIZE(info) ((unsigned char) (info))
+#define ELF32_M_INFO(sym, size) (((sym) << 8) + (unsigned char) (size))
+
+#define ELF64_M_SYM(info) ELF32_M_SYM (info)
+#define ELF64_M_SIZE(info) ELF32_M_SIZE (info)
+#define ELF64_M_INFO(sym, size) ELF32_M_INFO (sym, size)
+
+
+/* Motorola 68k specific definitions. */
+
+/* Values for Elf32_Ehdr.e_flags. */
+#define EF_CPU32 0x00810000
+
+/* m68k relocs. */
+
+#define R_68K_NONE 0 /* No reloc */
+#define R_68K_32 1 /* Direct 32 bit */
+#define R_68K_16 2 /* Direct 16 bit */
+#define R_68K_8 3 /* Direct 8 bit */
+#define R_68K_PC32 4 /* PC relative 32 bit */
+#define R_68K_PC16 5 /* PC relative 16 bit */
+#define R_68K_PC8 6 /* PC relative 8 bit */
+#define R_68K_GOT32 7 /* 32 bit PC relative GOT entry */
+#define R_68K_GOT16 8 /* 16 bit PC relative GOT entry */
+#define R_68K_GOT8 9 /* 8 bit PC relative GOT entry */
+#define R_68K_GOT32O 10 /* 32 bit GOT offset */
+#define R_68K_GOT16O 11 /* 16 bit GOT offset */
+#define R_68K_GOT8O 12 /* 8 bit GOT offset */
+#define R_68K_PLT32 13 /* 32 bit PC relative PLT address */
+#define R_68K_PLT16 14 /* 16 bit PC relative PLT address */
+#define R_68K_PLT8 15 /* 8 bit PC relative PLT address */
+#define R_68K_PLT32O 16 /* 32 bit PLT offset */
+#define R_68K_PLT16O 17 /* 16 bit PLT offset */
+#define R_68K_PLT8O 18 /* 8 bit PLT offset */
+#define R_68K_COPY 19 /* Copy symbol at runtime */
+#define R_68K_GLOB_DAT 20 /* Create GOT entry */
+#define R_68K_JMP_SLOT 21 /* Create PLT entry */
+#define R_68K_RELATIVE 22 /* Adjust by program base */
+/* Keep this the last entry. */
+#define R_68K_NUM 23
+
+/* Intel 80386 specific definitions. */
+
+/* i386 relocs. */
+
+#define R_386_NONE 0 /* No reloc */
+#define R_386_32 1 /* Direct 32 bit */
+#define R_386_PC32 2 /* PC relative 32 bit */
+#define R_386_GOT32 3 /* 32 bit GOT entry */
+#define R_386_PLT32 4 /* 32 bit PLT address */
+#define R_386_COPY 5 /* Copy symbol at runtime */
+#define R_386_GLOB_DAT 6 /* Create GOT entry */
+#define R_386_JMP_SLOT 7 /* Create PLT entry */
+#define R_386_RELATIVE 8 /* Adjust by program base */
+#define R_386_GOTOFF 9 /* 32 bit offset to GOT */
+#define R_386_GOTPC 10 /* 32 bit PC relative offset to GOT */
+#define R_386_32PLT 11
+#define R_386_TLS_TPOFF 14 /* Offset in static TLS block */
+#define R_386_TLS_IE 15 /* Address of GOT entry for static TLS
+ block offset */
+#define R_386_TLS_GOTIE 16 /* GOT entry for static TLS block
+ offset */
+#define R_386_TLS_LE 17 /* Offset relative to static TLS
+ block */
+#define R_386_TLS_GD 18 /* Direct 32 bit for GNU version of
+ general dynamic thread local data */
+#define R_386_TLS_LDM 19 /* Direct 32 bit for GNU version of
+ local dynamic thread local data
+ in LE code */
+#define R_386_16 20
+#define R_386_PC16 21
+#define R_386_8 22
+#define R_386_PC8 23
+#define R_386_TLS_GD_32 24 /* Direct 32 bit for general dynamic
+ thread local data */
+#define R_386_TLS_GD_PUSH 25 /* Tag for pushl in GD TLS code */
+#define R_386_TLS_GD_CALL 26 /* Relocation for call to
+ __tls_get_addr() */
+#define R_386_TLS_GD_POP 27 /* Tag for popl in GD TLS code */
+#define R_386_TLS_LDM_32 28 /* Direct 32 bit for local dynamic
+ thread local data in LE code */
+#define R_386_TLS_LDM_PUSH 29 /* Tag for pushl in LDM TLS code */
+#define R_386_TLS_LDM_CALL 30 /* Relocation for call to
+ __tls_get_addr() in LDM code */
+#define R_386_TLS_LDM_POP 31 /* Tag for popl in LDM TLS code */
+#define R_386_TLS_LDO_32 32 /* Offset relative to TLS block */
+#define R_386_TLS_IE_32 33 /* GOT entry for negated static TLS
+ block offset */
+#define R_386_TLS_LE_32 34 /* Negated offset relative to static
+ TLS block */
+#define R_386_TLS_DTPMOD32 35 /* ID of module containing symbol */
+#define R_386_TLS_DTPOFF32 36 /* Offset in TLS block */
+#define R_386_TLS_TPOFF32 37 /* Negated offset in static TLS block */
+/* Keep this the last entry. */
+#define R_386_NUM 38
+
+/* SUN SPARC specific definitions. */
+
+/* Legal values for ST_TYPE subfield of st_info (symbol type). */
+
+#define STT_SPARC_REGISTER 13 /* Global register reserved to app. */
+
+/* Values for Elf64_Ehdr.e_flags. */
+
+#define EF_SPARCV9_MM 3
+#define EF_SPARCV9_TSO 0
+#define EF_SPARCV9_PSO 1
+#define EF_SPARCV9_RMO 2
+#define EF_SPARC_LEDATA 0x800000 /* little endian data */
+#define EF_SPARC_EXT_MASK 0xFFFF00
+#define EF_SPARC_32PLUS 0x000100 /* generic V8+ features */
+#define EF_SPARC_SUN_US1 0x000200 /* Sun UltraSPARC1 extensions */
+#define EF_SPARC_HAL_R1 0x000400 /* HAL R1 extensions */
+#define EF_SPARC_SUN_US3 0x000800 /* Sun UltraSPARCIII extensions */
+
+/* SPARC relocs. */
+
+#define R_SPARC_NONE 0 /* No reloc */
+#define R_SPARC_8 1 /* Direct 8 bit */
+#define R_SPARC_16 2 /* Direct 16 bit */
+#define R_SPARC_32 3 /* Direct 32 bit */
+#define R_SPARC_DISP8 4 /* PC relative 8 bit */
+#define R_SPARC_DISP16 5 /* PC relative 16 bit */
+#define R_SPARC_DISP32 6 /* PC relative 32 bit */
+#define R_SPARC_WDISP30 7 /* PC relative 30 bit shifted */
+#define R_SPARC_WDISP22 8 /* PC relative 22 bit shifted */
+#define R_SPARC_HI22 9 /* High 22 bit */
+#define R_SPARC_22 10 /* Direct 22 bit */
+#define R_SPARC_13 11 /* Direct 13 bit */
+#define R_SPARC_LO10 12 /* Truncated 10 bit */
+#define R_SPARC_GOT10 13 /* Truncated 10 bit GOT entry */
+#define R_SPARC_GOT13 14 /* 13 bit GOT entry */
+#define R_SPARC_GOT22 15 /* 22 bit GOT entry shifted */
+#define R_SPARC_PC10 16 /* PC relative 10 bit truncated */
+#define R_SPARC_PC22 17 /* PC relative 22 bit shifted */
+#define R_SPARC_WPLT30 18 /* 30 bit PC relative PLT address */
+#define R_SPARC_COPY 19 /* Copy symbol at runtime */
+#define R_SPARC_GLOB_DAT 20 /* Create GOT entry */
+#define R_SPARC_JMP_SLOT 21 /* Create PLT entry */
+#define R_SPARC_RELATIVE 22 /* Adjust by program base */
+#define R_SPARC_UA32 23 /* Direct 32 bit unaligned */
+
+/* Additional Sparc64 relocs. */
+
+#define R_SPARC_PLT32 24 /* Direct 32 bit ref to PLT entry */
+#define R_SPARC_HIPLT22 25 /* High 22 bit PLT entry */
+#define R_SPARC_LOPLT10 26 /* Truncated 10 bit PLT entry */
+#define R_SPARC_PCPLT32 27 /* PC rel 32 bit ref to PLT entry */
+#define R_SPARC_PCPLT22 28 /* PC rel high 22 bit PLT entry */
+#define R_SPARC_PCPLT10 29 /* PC rel trunc 10 bit PLT entry */
+#define R_SPARC_10 30 /* Direct 10 bit */
+#define R_SPARC_11 31 /* Direct 11 bit */
+#define R_SPARC_64 32 /* Direct 64 bit */
+#define R_SPARC_OLO10 33 /* 10bit with secondary 13bit addend */
+#define R_SPARC_HH22 34 /* Top 22 bits of direct 64 bit */
+#define R_SPARC_HM10 35 /* High middle 10 bits of ... */
+#define R_SPARC_LM22 36 /* Low middle 22 bits of ... */
+#define R_SPARC_PC_HH22 37 /* Top 22 bits of pc rel 64 bit */
+#define R_SPARC_PC_HM10 38 /* High middle 10 bit of ... */
+#define R_SPARC_PC_LM22 39 /* Low miggle 22 bits of ... */
+#define R_SPARC_WDISP16 40 /* PC relative 16 bit shifted */
+#define R_SPARC_WDISP19 41 /* PC relative 19 bit shifted */
+#define R_SPARC_7 43 /* Direct 7 bit */
+#define R_SPARC_5 44 /* Direct 5 bit */
+#define R_SPARC_6 45 /* Direct 6 bit */
+#define R_SPARC_DISP64 46 /* PC relative 64 bit */
+#define R_SPARC_PLT64 47 /* Direct 64 bit ref to PLT entry */
+#define R_SPARC_HIX22 48 /* High 22 bit complemented */
+#define R_SPARC_LOX10 49 /* Truncated 11 bit complemented */
+#define R_SPARC_H44 50 /* Direct high 12 of 44 bit */
+#define R_SPARC_M44 51 /* Direct mid 22 of 44 bit */
+#define R_SPARC_L44 52 /* Direct low 10 of 44 bit */
+#define R_SPARC_REGISTER 53 /* Global register usage */
+#define R_SPARC_UA64 54 /* Direct 64 bit unaligned */
+#define R_SPARC_UA16 55 /* Direct 16 bit unaligned */
+#define R_SPARC_TLS_GD_HI22 56
+#define R_SPARC_TLS_GD_LO10 57
+#define R_SPARC_TLS_GD_ADD 58
+#define R_SPARC_TLS_GD_CALL 59
+#define R_SPARC_TLS_LDM_HI22 60
+#define R_SPARC_TLS_LDM_LO10 61
+#define R_SPARC_TLS_LDM_ADD 62
+#define R_SPARC_TLS_LDM_CALL 63
+#define R_SPARC_TLS_LDO_HIX22 64
+#define R_SPARC_TLS_LDO_LOX10 65
+#define R_SPARC_TLS_LDO_ADD 66
+#define R_SPARC_TLS_IE_HI22 67
+#define R_SPARC_TLS_IE_LO10 68
+#define R_SPARC_TLS_IE_LD 69
+#define R_SPARC_TLS_IE_LDX 70
+#define R_SPARC_TLS_IE_ADD 71
+#define R_SPARC_TLS_LE_HIX22 72
+#define R_SPARC_TLS_LE_LOX10 73
+#define R_SPARC_TLS_DTPMOD32 74
+#define R_SPARC_TLS_DTPMOD64 75
+#define R_SPARC_TLS_DTPOFF32 76
+#define R_SPARC_TLS_DTPOFF64 77
+#define R_SPARC_TLS_TPOFF32 78
+#define R_SPARC_TLS_TPOFF64 79
+/* Keep this the last entry. */
+#define R_SPARC_NUM 80
+
+/* For Sparc64, legal values for d_tag of Elf64_Dyn. */
+
+#define DT_SPARC_REGISTER 0x70000001
+#define DT_SPARC_NUM 2
+
+/* Bits present in AT_HWCAP on SPARC. */
+
+#define HWCAP_SPARC_FLUSH 1 /* The CPU supports flush insn. */
+#define HWCAP_SPARC_STBAR 2
+#define HWCAP_SPARC_SWAP 4
+#define HWCAP_SPARC_MULDIV 8
+#define HWCAP_SPARC_V9 16 /* The CPU is v9, so v8plus is ok. */
+#define HWCAP_SPARC_ULTRA3 32
+#define HWCAP_SPARC_BLKINIT 64 /* Sun4v with block-init/load-twin. */
+
+/* MIPS R3000 specific definitions. */
+
+/* Legal values for e_flags field of Elf32_Ehdr. */
+
+#define EF_MIPS_NOREORDER 1 /* A .noreorder directive was used */
+#define EF_MIPS_PIC 2 /* Contains PIC code */
+#define EF_MIPS_CPIC 4 /* Uses PIC calling sequence */
+#define EF_MIPS_XGOT 8
+#define EF_MIPS_64BIT_WHIRL 16
+#define EF_MIPS_ABI2 32
+#define EF_MIPS_ABI_ON32 64
+#define EF_MIPS_ARCH 0xf0000000 /* MIPS architecture level */
+
+/* Legal values for MIPS architecture level. */
+
+#define EF_MIPS_ARCH_1 0x00000000 /* -mips1 code. */
+#define EF_MIPS_ARCH_2 0x10000000 /* -mips2 code. */
+#define EF_MIPS_ARCH_3 0x20000000 /* -mips3 code. */
+#define EF_MIPS_ARCH_4 0x30000000 /* -mips4 code. */
+#define EF_MIPS_ARCH_5 0x40000000 /* -mips5 code. */
+#define EF_MIPS_ARCH_32 0x60000000 /* MIPS32 code. */
+#define EF_MIPS_ARCH_64 0x70000000 /* MIPS64 code. */
+
+/* The following are non-official names and should not be used. */
+
+#define E_MIPS_ARCH_1 0x00000000 /* -mips1 code. */
+#define E_MIPS_ARCH_2 0x10000000 /* -mips2 code. */
+#define E_MIPS_ARCH_3 0x20000000 /* -mips3 code. */
+#define E_MIPS_ARCH_4 0x30000000 /* -mips4 code. */
+#define E_MIPS_ARCH_5 0x40000000 /* -mips5 code. */
+#define E_MIPS_ARCH_32 0x60000000 /* MIPS32 code. */
+#define E_MIPS_ARCH_64 0x70000000 /* MIPS64 code. */
+
+/* Special section indices. */
+
+#define SHN_MIPS_ACOMMON 0xff00 /* Allocated common symbols */
+#define SHN_MIPS_TEXT 0xff01 /* Allocated test symbols. */
+#define SHN_MIPS_DATA 0xff02 /* Allocated data symbols. */
+#define SHN_MIPS_SCOMMON 0xff03 /* Small common symbols */
+#define SHN_MIPS_SUNDEFINED 0xff04 /* Small undefined symbols */
+
+/* Legal values for sh_type field of Elf32_Shdr. */
+
+#define SHT_MIPS_LIBLIST 0x70000000 /* Shared objects used in link */
+#define SHT_MIPS_MSYM 0x70000001
+#define SHT_MIPS_CONFLICT 0x70000002 /* Conflicting symbols */
+#define SHT_MIPS_GPTAB 0x70000003 /* Global data area sizes */
+#define SHT_MIPS_UCODE 0x70000004 /* Reserved for SGI/MIPS compilers */
+#define SHT_MIPS_DEBUG 0x70000005 /* MIPS ECOFF debugging information*/
+#define SHT_MIPS_REGINFO 0x70000006 /* Register usage information */
+#define SHT_MIPS_PACKAGE 0x70000007
+#define SHT_MIPS_PACKSYM 0x70000008
+#define SHT_MIPS_RELD 0x70000009
+#define SHT_MIPS_IFACE 0x7000000b
+#define SHT_MIPS_CONTENT 0x7000000c
+#define SHT_MIPS_OPTIONS 0x7000000d /* Miscellaneous options. */
+#define SHT_MIPS_SHDR 0x70000010
+#define SHT_MIPS_FDESC 0x70000011
+#define SHT_MIPS_EXTSYM 0x70000012
+#define SHT_MIPS_DENSE 0x70000013
+#define SHT_MIPS_PDESC 0x70000014
+#define SHT_MIPS_LOCSYM 0x70000015
+#define SHT_MIPS_AUXSYM 0x70000016
+#define SHT_MIPS_OPTSYM 0x70000017
+#define SHT_MIPS_LOCSTR 0x70000018
+#define SHT_MIPS_LINE 0x70000019
+#define SHT_MIPS_RFDESC 0x7000001a
+#define SHT_MIPS_DELTASYM 0x7000001b
+#define SHT_MIPS_DELTAINST 0x7000001c
+#define SHT_MIPS_DELTACLASS 0x7000001d
+#define SHT_MIPS_DWARF 0x7000001e /* DWARF debugging information. */
+#define SHT_MIPS_DELTADECL 0x7000001f
+#define SHT_MIPS_SYMBOL_LIB 0x70000020
+#define SHT_MIPS_EVENTS 0x70000021 /* Event section. */
+#define SHT_MIPS_TRANSLATE 0x70000022
+#define SHT_MIPS_PIXIE 0x70000023
+#define SHT_MIPS_XLATE 0x70000024
+#define SHT_MIPS_XLATE_DEBUG 0x70000025
+#define SHT_MIPS_WHIRL 0x70000026
+#define SHT_MIPS_EH_REGION 0x70000027
+#define SHT_MIPS_XLATE_OLD 0x70000028
+#define SHT_MIPS_PDR_EXCEPTION 0x70000029
+
+/* Legal values for sh_flags field of Elf32_Shdr. */
+
+#define SHF_MIPS_GPREL 0x10000000 /* Must be part of global data area */
+#define SHF_MIPS_MERGE 0x20000000
+#define SHF_MIPS_ADDR 0x40000000
+#define SHF_MIPS_STRINGS 0x80000000
+#define SHF_MIPS_NOSTRIP 0x08000000
+#define SHF_MIPS_LOCAL 0x04000000
+#define SHF_MIPS_NAMES 0x02000000
+#define SHF_MIPS_NODUPE 0x01000000
+
+
+/* Symbol tables. */
+
+/* MIPS specific values for `st_other'. */
+#define STO_MIPS_DEFAULT 0x0
+#define STO_MIPS_INTERNAL 0x1
+#define STO_MIPS_HIDDEN 0x2
+#define STO_MIPS_PROTECTED 0x3
+#define STO_MIPS_SC_ALIGN_UNUSED 0xff
+
+/* MIPS specific values for `st_info'. */
+#define STB_MIPS_SPLIT_COMMON 13
+
+/* Entries found in sections of type SHT_MIPS_GPTAB. */
+
+typedef union
+{
+ struct
+ {
+ Elf32_Word gt_current_g_value; /* -G value used for compilation */
+ Elf32_Word gt_unused; /* Not used */
+ } gt_header; /* First entry in section */
+ struct
+ {
+ Elf32_Word gt_g_value; /* If this value were used for -G */
+ Elf32_Word gt_bytes; /* This many bytes would be used */
+ } gt_entry; /* Subsequent entries in section */
+} Elf32_gptab;
+
+/* Entry found in sections of type SHT_MIPS_REGINFO. */
+
+typedef struct
+{
+ Elf32_Word ri_gprmask; /* General registers used */
+ Elf32_Word ri_cprmask[4]; /* Coprocessor registers used */
+ Elf32_Sword ri_gp_value; /* $gp register value */
+} Elf32_RegInfo;
+
+/* Entries found in sections of type SHT_MIPS_OPTIONS. */
+
+typedef struct
+{
+ unsigned char kind; /* Determines interpretation of the
+ variable part of descriptor. */
+ unsigned char size; /* Size of descriptor, including header. */
+ Elf32_Section section; /* Section header index of section affected,
+ 0 for global options. */
+ Elf32_Word info; /* Kind-specific information. */
+} Elf_Options;
+
+/* Values for `kind' field in Elf_Options. */
+
+#define ODK_NULL 0 /* Undefined. */
+#define ODK_REGINFO 1 /* Register usage information. */
+#define ODK_EXCEPTIONS 2 /* Exception processing options. */
+#define ODK_PAD 3 /* Section padding options. */
+#define ODK_HWPATCH 4 /* Hardware workarounds performed */
+#define ODK_FILL 5 /* record the fill value used by the linker. */
+#define ODK_TAGS 6 /* reserve space for desktop tools to write. */
+#define ODK_HWAND 7 /* HW workarounds. 'AND' bits when merging. */
+#define ODK_HWOR 8 /* HW workarounds. 'OR' bits when merging. */
+
+/* Values for `info' in Elf_Options for ODK_EXCEPTIONS entries. */
+
+#define OEX_FPU_MIN 0x1f /* FPE's which MUST be enabled. */
+#define OEX_FPU_MAX 0x1f00 /* FPE's which MAY be enabled. */
+#define OEX_PAGE0 0x10000 /* page zero must be mapped. */
+#define OEX_SMM 0x20000 /* Force sequential memory mode? */
+#define OEX_FPDBUG 0x40000 /* Force floating point debug mode? */
+#define OEX_PRECISEFP OEX_FPDBUG
+#define OEX_DISMISS 0x80000 /* Dismiss invalid address faults? */
+
+#define OEX_FPU_INVAL 0x10
+#define OEX_FPU_DIV0 0x08
+#define OEX_FPU_OFLO 0x04
+#define OEX_FPU_UFLO 0x02
+#define OEX_FPU_INEX 0x01
+
+/* Masks for `info' in Elf_Options for an ODK_HWPATCH entry. */
+
+#define OHW_R4KEOP 0x1 /* R4000 end-of-page patch. */
+#define OHW_R8KPFETCH 0x2 /* may need R8000 prefetch patch. */
+#define OHW_R5KEOP 0x4 /* R5000 end-of-page patch. */
+#define OHW_R5KCVTL 0x8 /* R5000 cvt.[ds].l bug. clean=1. */
+
+#define OPAD_PREFIX 0x1
+#define OPAD_POSTFIX 0x2
+#define OPAD_SYMBOL 0x4
+
+/* Entry found in `.options' section. */
+
+typedef struct
+{
+ Elf32_Word hwp_flags1; /* Extra flags. */
+ Elf32_Word hwp_flags2; /* Extra flags. */
+} Elf_Options_Hw;
+
+/* Masks for `info' in ElfOptions for ODK_HWAND and ODK_HWOR entries. */
+
+#define OHWA0_R4KEOP_CHECKED 0x00000001
+#define OHWA1_R4KEOP_CLEAN 0x00000002
+
+/* MIPS relocs. */
+
+#define R_MIPS_NONE 0 /* No reloc */
+#define R_MIPS_16 1 /* Direct 16 bit */
+#define R_MIPS_32 2 /* Direct 32 bit */
+#define R_MIPS_REL32 3 /* PC relative 32 bit */
+#define R_MIPS_26 4 /* Direct 26 bit shifted */
+#define R_MIPS_HI16 5 /* High 16 bit */
+#define R_MIPS_LO16 6 /* Low 16 bit */
+#define R_MIPS_GPREL16 7 /* GP relative 16 bit */
+#define R_MIPS_LITERAL 8 /* 16 bit literal entry */
+#define R_MIPS_GOT16 9 /* 16 bit GOT entry */
+#define R_MIPS_PC16 10 /* PC relative 16 bit */
+#define R_MIPS_CALL16 11 /* 16 bit GOT entry for function */
+#define R_MIPS_GPREL32 12 /* GP relative 32 bit */
+
+#define R_MIPS_SHIFT5 16
+#define R_MIPS_SHIFT6 17
+#define R_MIPS_64 18
+#define R_MIPS_GOT_DISP 19
+#define R_MIPS_GOT_PAGE 20
+#define R_MIPS_GOT_OFST 21
+#define R_MIPS_GOT_HI16 22
+#define R_MIPS_GOT_LO16 23
+#define R_MIPS_SUB 24
+#define R_MIPS_INSERT_A 25
+#define R_MIPS_INSERT_B 26
+#define R_MIPS_DELETE 27
+#define R_MIPS_HIGHER 28
+#define R_MIPS_HIGHEST 29
+#define R_MIPS_CALL_HI16 30
+#define R_MIPS_CALL_LO16 31
+#define R_MIPS_SCN_DISP 32
+#define R_MIPS_REL16 33
+#define R_MIPS_ADD_IMMEDIATE 34
+#define R_MIPS_PJUMP 35
+#define R_MIPS_RELGOT 36
+#define R_MIPS_JALR 37
+#define R_MIPS_TLS_DTPMOD32 38 /* Module number 32 bit */
+#define R_MIPS_TLS_DTPREL32 39 /* Module-relative offset 32 bit */
+#define R_MIPS_TLS_DTPMOD64 40 /* Module number 64 bit */
+#define R_MIPS_TLS_DTPREL64 41 /* Module-relative offset 64 bit */
+#define R_MIPS_TLS_GD 42 /* 16 bit GOT offset for GD */
+#define R_MIPS_TLS_LDM 43 /* 16 bit GOT offset for LDM */
+#define R_MIPS_TLS_DTPREL_HI16 44 /* Module-relative offset, high 16 bits */
+#define R_MIPS_TLS_DTPREL_LO16 45 /* Module-relative offset, low 16 bits */
+#define R_MIPS_TLS_GOTTPREL 46 /* 16 bit GOT offset for IE */
+#define R_MIPS_TLS_TPREL32 47 /* TP-relative offset, 32 bit */
+#define R_MIPS_TLS_TPREL64 48 /* TP-relative offset, 64 bit */
+#define R_MIPS_TLS_TPREL_HI16 49 /* TP-relative offset, high 16 bits */
+#define R_MIPS_TLS_TPREL_LO16 50 /* TP-relative offset, low 16 bits */
+#define R_MIPS_GLOB_DAT 51
+/* Keep this the last entry. */
+#define R_MIPS_NUM 52
+
+/* Legal values for p_type field of Elf32_Phdr. */
+
+#define PT_MIPS_REGINFO 0x70000000 /* Register usage information */
+#define PT_MIPS_RTPROC 0x70000001 /* Runtime procedure table. */
+#define PT_MIPS_OPTIONS 0x70000002
+
+/* Special program header types. */
+
+#define PF_MIPS_LOCAL 0x10000000
+
+/* Legal values for d_tag field of Elf32_Dyn. */
+
+#define DT_MIPS_RLD_VERSION 0x70000001 /* Runtime linker interface version */
+#define DT_MIPS_TIME_STAMP 0x70000002 /* Timestamp */
+#define DT_MIPS_ICHECKSUM 0x70000003 /* Checksum */
+#define DT_MIPS_IVERSION 0x70000004 /* Version string (string tbl index) */
+#define DT_MIPS_FLAGS 0x70000005 /* Flags */
+#define DT_MIPS_BASE_ADDRESS 0x70000006 /* Base address */
+#define DT_MIPS_MSYM 0x70000007
+#define DT_MIPS_CONFLICT 0x70000008 /* Address of CONFLICT section */
+#define DT_MIPS_LIBLIST 0x70000009 /* Address of LIBLIST section */
+#define DT_MIPS_LOCAL_GOTNO 0x7000000a /* Number of local GOT entries */
+#define DT_MIPS_CONFLICTNO 0x7000000b /* Number of CONFLICT entries */
+#define DT_MIPS_LIBLISTNO 0x70000010 /* Number of LIBLIST entries */
+#define DT_MIPS_SYMTABNO 0x70000011 /* Number of DYNSYM entries */
+#define DT_MIPS_UNREFEXTNO 0x70000012 /* First external DYNSYM */
+#define DT_MIPS_GOTSYM 0x70000013 /* First GOT entry in DYNSYM */
+#define DT_MIPS_HIPAGENO 0x70000014 /* Number of GOT page table entries */
+#define DT_MIPS_RLD_MAP 0x70000016 /* Address of run time loader map. */
+#define DT_MIPS_DELTA_CLASS 0x70000017 /* Delta C++ class definition. */
+#define DT_MIPS_DELTA_CLASS_NO 0x70000018 /* Number of entries in
+ DT_MIPS_DELTA_CLASS. */
+#define DT_MIPS_DELTA_INSTANCE 0x70000019 /* Delta C++ class instances. */
+#define DT_MIPS_DELTA_INSTANCE_NO 0x7000001a /* Number of entries in
+ DT_MIPS_DELTA_INSTANCE. */
+#define DT_MIPS_DELTA_RELOC 0x7000001b /* Delta relocations. */
+#define DT_MIPS_DELTA_RELOC_NO 0x7000001c /* Number of entries in
+ DT_MIPS_DELTA_RELOC. */
+#define DT_MIPS_DELTA_SYM 0x7000001d /* Delta symbols that Delta
+ relocations refer to. */
+#define DT_MIPS_DELTA_SYM_NO 0x7000001e /* Number of entries in
+ DT_MIPS_DELTA_SYM. */
+#define DT_MIPS_DELTA_CLASSSYM 0x70000020 /* Delta symbols that hold the
+ class declaration. */
+#define DT_MIPS_DELTA_CLASSSYM_NO 0x70000021 /* Number of entries in
+ DT_MIPS_DELTA_CLASSSYM. */
+#define DT_MIPS_CXX_FLAGS 0x70000022 /* Flags indicating for C++ flavor. */
+#define DT_MIPS_PIXIE_INIT 0x70000023
+#define DT_MIPS_SYMBOL_LIB 0x70000024
+#define DT_MIPS_LOCALPAGE_GOTIDX 0x70000025
+#define DT_MIPS_LOCAL_GOTIDX 0x70000026
+#define DT_MIPS_HIDDEN_GOTIDX 0x70000027
+#define DT_MIPS_PROTECTED_GOTIDX 0x70000028
+#define DT_MIPS_OPTIONS 0x70000029 /* Address of .options. */
+#define DT_MIPS_INTERFACE 0x7000002a /* Address of .interface. */
+#define DT_MIPS_DYNSTR_ALIGN 0x7000002b
+#define DT_MIPS_INTERFACE_SIZE 0x7000002c /* Size of the .interface section. */
+#define DT_MIPS_RLD_TEXT_RESOLVE_ADDR 0x7000002d /* Address of rld_text_rsolve
+ function stored in GOT. */
+#define DT_MIPS_PERF_SUFFIX 0x7000002e /* Default suffix of dso to be added
+ by rld on dlopen() calls. */
+#define DT_MIPS_COMPACT_SIZE 0x7000002f /* (O32)Size of compact rel section. */
+#define DT_MIPS_GP_VALUE 0x70000030 /* GP value for aux GOTs. */
+#define DT_MIPS_AUX_DYNAMIC 0x70000031 /* Address of aux .dynamic. */
+#define DT_MIPS_NUM 0x32
+
+/* Legal values for DT_MIPS_FLAGS Elf32_Dyn entry. */
+
+#define RHF_NONE 0 /* No flags */
+#define RHF_QUICKSTART (1 << 0) /* Use quickstart */
+#define RHF_NOTPOT (1 << 1) /* Hash size not power of 2 */
+#define RHF_NO_LIBRARY_REPLACEMENT (1 << 2) /* Ignore LD_LIBRARY_PATH */
+#define RHF_NO_MOVE (1 << 3)
+#define RHF_SGI_ONLY (1 << 4)
+#define RHF_GUARANTEE_INIT (1 << 5)
+#define RHF_DELTA_C_PLUS_PLUS (1 << 6)
+#define RHF_GUARANTEE_START_INIT (1 << 7)
+#define RHF_PIXIE (1 << 8)
+#define RHF_DEFAULT_DELAY_LOAD (1 << 9)
+#define RHF_REQUICKSTART (1 << 10)
+#define RHF_REQUICKSTARTED (1 << 11)
+#define RHF_CORD (1 << 12)
+#define RHF_NO_UNRES_UNDEF (1 << 13)
+#define RHF_RLD_ORDER_SAFE (1 << 14)
+
+/* Entries found in sections of type SHT_MIPS_LIBLIST. */
+
+typedef struct
+{
+ Elf32_Word l_name; /* Name (string table index) */
+ Elf32_Word l_time_stamp; /* Timestamp */
+ Elf32_Word l_checksum; /* Checksum */
+ Elf32_Word l_version; /* Interface version */
+ Elf32_Word l_flags; /* Flags */
+} Elf32_Lib;
+
+typedef struct
+{
+ Elf64_Word l_name; /* Name (string table index) */
+ Elf64_Word l_time_stamp; /* Timestamp */
+ Elf64_Word l_checksum; /* Checksum */
+ Elf64_Word l_version; /* Interface version */
+ Elf64_Word l_flags; /* Flags */
+} Elf64_Lib;
+
+
+/* Legal values for l_flags. */
+
+#define LL_NONE 0
+#define LL_EXACT_MATCH (1 << 0) /* Require exact match */
+#define LL_IGNORE_INT_VER (1 << 1) /* Ignore interface version */
+#define LL_REQUIRE_MINOR (1 << 2)
+#define LL_EXPORTS (1 << 3)
+#define LL_DELAY_LOAD (1 << 4)
+#define LL_DELTA (1 << 5)
+
+/* Entries found in sections of type SHT_MIPS_CONFLICT. */
+
+typedef Elf32_Addr Elf32_Conflict;
+
+
+/* HPPA specific definitions. */
+
+/* Legal values for e_flags field of Elf32_Ehdr. */
+
+#define EF_PARISC_TRAPNIL 0x00010000 /* Trap nil pointer dereference. */
+#define EF_PARISC_EXT 0x00020000 /* Program uses arch. extensions. */
+#define EF_PARISC_LSB 0x00040000 /* Program expects little endian. */
+#define EF_PARISC_WIDE 0x00080000 /* Program expects wide mode. */
+#define EF_PARISC_NO_KABP 0x00100000 /* No kernel assisted branch
+ prediction. */
+#define EF_PARISC_LAZYSWAP 0x00400000 /* Allow lazy swapping. */
+#define EF_PARISC_ARCH 0x0000ffff /* Architecture version. */
+
+/* Defined values for `e_flags & EF_PARISC_ARCH' are: */
+
+#define EFA_PARISC_1_0 0x020b /* PA-RISC 1.0 big-endian. */
+#define EFA_PARISC_1_1 0x0210 /* PA-RISC 1.1 big-endian. */
+#define EFA_PARISC_2_0 0x0214 /* PA-RISC 2.0 big-endian. */
+
+/* Additional section indeces. */
+
+#define SHN_PARISC_ANSI_COMMON 0xff00 /* Section for tenatively declared
+ symbols in ANSI C. */
+#define SHN_PARISC_HUGE_COMMON 0xff01 /* Common blocks in huge model. */
+
+/* Legal values for sh_type field of Elf32_Shdr. */
+
+#define SHT_PARISC_EXT 0x70000000 /* Contains product specific ext. */
+#define SHT_PARISC_UNWIND 0x70000001 /* Unwind information. */
+#define SHT_PARISC_DOC 0x70000002 /* Debug info for optimized code. */
+
+/* Legal values for sh_flags field of Elf32_Shdr. */
+
+#define SHF_PARISC_SHORT 0x20000000 /* Section with short addressing. */
+#define SHF_PARISC_HUGE 0x40000000 /* Section far from gp. */
+#define SHF_PARISC_SBP 0x80000000 /* Static branch prediction code. */
+
+/* Legal values for ST_TYPE subfield of st_info (symbol type). */
+
+#define STT_PARISC_MILLICODE 13 /* Millicode function entry point. */
+
+#define STT_HP_OPAQUE (STT_LOOS + 0x1)
+#define STT_HP_STUB (STT_LOOS + 0x2)
+
+/* HPPA relocs. */
+
+#define R_PARISC_NONE 0 /* No reloc. */
+#define R_PARISC_DIR32 1 /* Direct 32-bit reference. */
+#define R_PARISC_DIR21L 2 /* Left 21 bits of eff. address. */
+#define R_PARISC_DIR17R 3 /* Right 17 bits of eff. address. */
+#define R_PARISC_DIR17F 4 /* 17 bits of eff. address. */
+#define R_PARISC_DIR14R 6 /* Right 14 bits of eff. address. */
+#define R_PARISC_PCREL32 9 /* 32-bit rel. address. */
+#define R_PARISC_PCREL21L 10 /* Left 21 bits of rel. address. */
+#define R_PARISC_PCREL17R 11 /* Right 17 bits of rel. address. */
+#define R_PARISC_PCREL17F 12 /* 17 bits of rel. address. */
+#define R_PARISC_PCREL14R 14 /* Right 14 bits of rel. address. */
+#define R_PARISC_DPREL21L 18 /* Left 21 bits of rel. address. */
+#define R_PARISC_DPREL14R 22 /* Right 14 bits of rel. address. */
+#define R_PARISC_GPREL21L 26 /* GP-relative, left 21 bits. */
+#define R_PARISC_GPREL14R 30 /* GP-relative, right 14 bits. */
+#define R_PARISC_LTOFF21L 34 /* LT-relative, left 21 bits. */
+#define R_PARISC_LTOFF14R 38 /* LT-relative, right 14 bits. */
+#define R_PARISC_SECREL32 41 /* 32 bits section rel. address. */
+#define R_PARISC_SEGBASE 48 /* No relocation, set segment base. */
+#define R_PARISC_SEGREL32 49 /* 32 bits segment rel. address. */
+#define R_PARISC_PLTOFF21L 50 /* PLT rel. address, left 21 bits. */
+#define R_PARISC_PLTOFF14R 54 /* PLT rel. address, right 14 bits. */
+#define R_PARISC_LTOFF_FPTR32 57 /* 32 bits LT-rel. function pointer. */
+#define R_PARISC_LTOFF_FPTR21L 58 /* LT-rel. fct ptr, left 21 bits. */
+#define R_PARISC_LTOFF_FPTR14R 62 /* LT-rel. fct ptr, right 14 bits. */
+#define R_PARISC_FPTR64 64 /* 64 bits function address. */
+#define R_PARISC_PLABEL32 65 /* 32 bits function address. */
+#define R_PARISC_PLABEL21L 66 /* Left 21 bits of fdesc address. */
+#define R_PARISC_PLABEL14R 70 /* Right 14 bits of fdesc address. */
+#define R_PARISC_PCREL64 72 /* 64 bits PC-rel. address. */
+#define R_PARISC_PCREL22F 74 /* 22 bits PC-rel. address. */
+#define R_PARISC_PCREL14WR 75 /* PC-rel. address, right 14 bits. */
+#define R_PARISC_PCREL14DR 76 /* PC rel. address, right 14 bits. */
+#define R_PARISC_PCREL16F 77 /* 16 bits PC-rel. address. */
+#define R_PARISC_PCREL16WF 78 /* 16 bits PC-rel. address. */
+#define R_PARISC_PCREL16DF 79 /* 16 bits PC-rel. address. */
+#define R_PARISC_DIR64 80 /* 64 bits of eff. address. */
+#define R_PARISC_DIR14WR 83 /* 14 bits of eff. address. */
+#define R_PARISC_DIR14DR 84 /* 14 bits of eff. address. */
+#define R_PARISC_DIR16F 85 /* 16 bits of eff. address. */
+#define R_PARISC_DIR16WF 86 /* 16 bits of eff. address. */
+#define R_PARISC_DIR16DF 87 /* 16 bits of eff. address. */
+#define R_PARISC_GPREL64 88 /* 64 bits of GP-rel. address. */
+#define R_PARISC_GPREL14WR 91 /* GP-rel. address, right 14 bits. */
+#define R_PARISC_GPREL14DR 92 /* GP-rel. address, right 14 bits. */
+#define R_PARISC_GPREL16F 93 /* 16 bits GP-rel. address. */
+#define R_PARISC_GPREL16WF 94 /* 16 bits GP-rel. address. */
+#define R_PARISC_GPREL16DF 95 /* 16 bits GP-rel. address. */
+#define R_PARISC_LTOFF64 96 /* 64 bits LT-rel. address. */
+#define R_PARISC_LTOFF14WR 99 /* LT-rel. address, right 14 bits. */
+#define R_PARISC_LTOFF14DR 100 /* LT-rel. address, right 14 bits. */
+#define R_PARISC_LTOFF16F 101 /* 16 bits LT-rel. address. */
+#define R_PARISC_LTOFF16WF 102 /* 16 bits LT-rel. address. */
+#define R_PARISC_LTOFF16DF 103 /* 16 bits LT-rel. address. */
+#define R_PARISC_SECREL64 104 /* 64 bits section rel. address. */
+#define R_PARISC_SEGREL64 112 /* 64 bits segment rel. address. */
+#define R_PARISC_PLTOFF14WR 115 /* PLT-rel. address, right 14 bits. */
+#define R_PARISC_PLTOFF14DR 116 /* PLT-rel. address, right 14 bits. */
+#define R_PARISC_PLTOFF16F 117 /* 16 bits LT-rel. address. */
+#define R_PARISC_PLTOFF16WF 118 /* 16 bits PLT-rel. address. */
+#define R_PARISC_PLTOFF16DF 119 /* 16 bits PLT-rel. address. */
+#define R_PARISC_LTOFF_FPTR64 120 /* 64 bits LT-rel. function ptr. */
+#define R_PARISC_LTOFF_FPTR14WR 123 /* LT-rel. fct. ptr., right 14 bits. */
+#define R_PARISC_LTOFF_FPTR14DR 124 /* LT-rel. fct. ptr., right 14 bits. */
+#define R_PARISC_LTOFF_FPTR16F 125 /* 16 bits LT-rel. function ptr. */
+#define R_PARISC_LTOFF_FPTR16WF 126 /* 16 bits LT-rel. function ptr. */
+#define R_PARISC_LTOFF_FPTR16DF 127 /* 16 bits LT-rel. function ptr. */
+#define R_PARISC_LORESERVE 128
+#define R_PARISC_COPY 128 /* Copy relocation. */
+#define R_PARISC_IPLT 129 /* Dynamic reloc, imported PLT */
+#define R_PARISC_EPLT 130 /* Dynamic reloc, exported PLT */
+#define R_PARISC_TPREL32 153 /* 32 bits TP-rel. address. */
+#define R_PARISC_TPREL21L 154 /* TP-rel. address, left 21 bits. */
+#define R_PARISC_TPREL14R 158 /* TP-rel. address, right 14 bits. */
+#define R_PARISC_LTOFF_TP21L 162 /* LT-TP-rel. address, left 21 bits. */
+#define R_PARISC_LTOFF_TP14R 166 /* LT-TP-rel. address, right 14 bits.*/
+#define R_PARISC_LTOFF_TP14F 167 /* 14 bits LT-TP-rel. address. */
+#define R_PARISC_TPREL64 216 /* 64 bits TP-rel. address. */
+#define R_PARISC_TPREL14WR 219 /* TP-rel. address, right 14 bits. */
+#define R_PARISC_TPREL14DR 220 /* TP-rel. address, right 14 bits. */
+#define R_PARISC_TPREL16F 221 /* 16 bits TP-rel. address. */
+#define R_PARISC_TPREL16WF 222 /* 16 bits TP-rel. address. */
+#define R_PARISC_TPREL16DF 223 /* 16 bits TP-rel. address. */
+#define R_PARISC_LTOFF_TP64 224 /* 64 bits LT-TP-rel. address. */
+#define R_PARISC_LTOFF_TP14WR 227 /* LT-TP-rel. address, right 14 bits.*/
+#define R_PARISC_LTOFF_TP14DR 228 /* LT-TP-rel. address, right 14 bits.*/
+#define R_PARISC_LTOFF_TP16F 229 /* 16 bits LT-TP-rel. address. */
+#define R_PARISC_LTOFF_TP16WF 230 /* 16 bits LT-TP-rel. address. */
+#define R_PARISC_LTOFF_TP16DF 231 /* 16 bits LT-TP-rel. address. */
+#define R_PARISC_GNU_VTENTRY 232
+#define R_PARISC_GNU_VTINHERIT 233
+#define R_PARISC_TLS_GD21L 234 /* GD 21-bit left. */
+#define R_PARISC_TLS_GD14R 235 /* GD 14-bit right. */
+#define R_PARISC_TLS_GDCALL 236 /* GD call to __t_g_a. */
+#define R_PARISC_TLS_LDM21L 237 /* LD module 21-bit left. */
+#define R_PARISC_TLS_LDM14R 238 /* LD module 14-bit right. */
+#define R_PARISC_TLS_LDMCALL 239 /* LD module call to __t_g_a. */
+#define R_PARISC_TLS_LDO21L 240 /* LD offset 21-bit left. */
+#define R_PARISC_TLS_LDO14R 241 /* LD offset 14-bit right. */
+#define R_PARISC_TLS_DTPMOD32 242 /* DTP module 32-bit. */
+#define R_PARISC_TLS_DTPMOD64 243 /* DTP module 64-bit. */
+#define R_PARISC_TLS_DTPOFF32 244 /* DTP offset 32-bit. */
+#define R_PARISC_TLS_DTPOFF64 245 /* DTP offset 32-bit. */
+#define R_PARISC_TLS_LE21L R_PARISC_TPREL21L
+#define R_PARISC_TLS_LE14R R_PARISC_TPREL14R
+#define R_PARISC_TLS_IE21L R_PARISC_LTOFF_TP21L
+#define R_PARISC_TLS_IE14R R_PARISC_LTOFF_TP14R
+#define R_PARISC_TLS_TPREL32 R_PARISC_TPREL32
+#define R_PARISC_TLS_TPREL64 R_PARISC_TPREL64
+#define R_PARISC_HIRESERVE 255
+
+/* Legal values for p_type field of Elf32_Phdr/Elf64_Phdr. */
+
+#define PT_HP_TLS (PT_LOOS + 0x0)
+#define PT_HP_CORE_NONE (PT_LOOS + 0x1)
+#define PT_HP_CORE_VERSION (PT_LOOS + 0x2)
+#define PT_HP_CORE_KERNEL (PT_LOOS + 0x3)
+#define PT_HP_CORE_COMM (PT_LOOS + 0x4)
+#define PT_HP_CORE_PROC (PT_LOOS + 0x5)
+#define PT_HP_CORE_LOADABLE (PT_LOOS + 0x6)
+#define PT_HP_CORE_STACK (PT_LOOS + 0x7)
+#define PT_HP_CORE_SHM (PT_LOOS + 0x8)
+#define PT_HP_CORE_MMF (PT_LOOS + 0x9)
+#define PT_HP_PARALLEL (PT_LOOS + 0x10)
+#define PT_HP_FASTBIND (PT_LOOS + 0x11)
+#define PT_HP_OPT_ANNOT (PT_LOOS + 0x12)
+#define PT_HP_HSL_ANNOT (PT_LOOS + 0x13)
+#define PT_HP_STACK (PT_LOOS + 0x14)
+
+#define PT_PARISC_ARCHEXT 0x70000000
+#define PT_PARISC_UNWIND 0x70000001
+
+/* Legal values for p_flags field of Elf32_Phdr/Elf64_Phdr. */
+
+#define PF_PARISC_SBP 0x08000000
+
+#define PF_HP_PAGE_SIZE 0x00100000
+#define PF_HP_FAR_SHARED 0x00200000
+#define PF_HP_NEAR_SHARED 0x00400000
+#define PF_HP_CODE 0x01000000
+#define PF_HP_MODIFY 0x02000000
+#define PF_HP_LAZYSWAP 0x04000000
+#define PF_HP_SBP 0x08000000
+
+
+/* Alpha specific definitions. */
+
+/* Legal values for e_flags field of Elf64_Ehdr. */
+
+#define EF_ALPHA_32BIT 1 /* All addresses must be < 2GB. */
+#define EF_ALPHA_CANRELAX 2 /* Relocations for relaxing exist. */
+
+/* Legal values for sh_type field of Elf64_Shdr. */
+
+/* These two are primerily concerned with ECOFF debugging info. */
+#define SHT_ALPHA_DEBUG 0x70000001
+#define SHT_ALPHA_REGINFO 0x70000002
+
+/* Legal values for sh_flags field of Elf64_Shdr. */
+
+#define SHF_ALPHA_GPREL 0x10000000
+
+/* Legal values for st_other field of Elf64_Sym. */
+#define STO_ALPHA_NOPV 0x80 /* No PV required. */
+#define STO_ALPHA_STD_GPLOAD 0x88 /* PV only used for initial ldgp. */
+
+/* Alpha relocs. */
+
+#define R_ALPHA_NONE 0 /* No reloc */
+#define R_ALPHA_REFLONG 1 /* Direct 32 bit */
+#define R_ALPHA_REFQUAD 2 /* Direct 64 bit */
+#define R_ALPHA_GPREL32 3 /* GP relative 32 bit */
+#define R_ALPHA_LITERAL 4 /* GP relative 16 bit w/optimization */
+#define R_ALPHA_LITUSE 5 /* Optimization hint for LITERAL */
+#define R_ALPHA_GPDISP 6 /* Add displacement to GP */
+#define R_ALPHA_BRADDR 7 /* PC+4 relative 23 bit shifted */
+#define R_ALPHA_HINT 8 /* PC+4 relative 16 bit shifted */
+#define R_ALPHA_SREL16 9 /* PC relative 16 bit */
+#define R_ALPHA_SREL32 10 /* PC relative 32 bit */
+#define R_ALPHA_SREL64 11 /* PC relative 64 bit */
+#define R_ALPHA_GPRELHIGH 17 /* GP relative 32 bit, high 16 bits */
+#define R_ALPHA_GPRELLOW 18 /* GP relative 32 bit, low 16 bits */
+#define R_ALPHA_GPREL16 19 /* GP relative 16 bit */
+#define R_ALPHA_COPY 24 /* Copy symbol at runtime */
+#define R_ALPHA_GLOB_DAT 25 /* Create GOT entry */
+#define R_ALPHA_JMP_SLOT 26 /* Create PLT entry */
+#define R_ALPHA_RELATIVE 27 /* Adjust by program base */
+#define R_ALPHA_TLS_GD_HI 28
+#define R_ALPHA_TLSGD 29
+#define R_ALPHA_TLS_LDM 30
+#define R_ALPHA_DTPMOD64 31
+#define R_ALPHA_GOTDTPREL 32
+#define R_ALPHA_DTPREL64 33
+#define R_ALPHA_DTPRELHI 34
+#define R_ALPHA_DTPRELLO 35
+#define R_ALPHA_DTPREL16 36
+#define R_ALPHA_GOTTPREL 37
+#define R_ALPHA_TPREL64 38
+#define R_ALPHA_TPRELHI 39
+#define R_ALPHA_TPRELLO 40
+#define R_ALPHA_TPREL16 41
+/* Keep this the last entry. */
+#define R_ALPHA_NUM 46
+
+/* Magic values of the LITUSE relocation addend. */
+#define LITUSE_ALPHA_ADDR 0
+#define LITUSE_ALPHA_BASE 1
+#define LITUSE_ALPHA_BYTOFF 2
+#define LITUSE_ALPHA_JSR 3
+#define LITUSE_ALPHA_TLS_GD 4
+#define LITUSE_ALPHA_TLS_LDM 5
+
+/* Legal values for d_tag of Elf64_Dyn. */
+#define DT_ALPHA_PLTRO (DT_LOPROC + 0)
+#define DT_ALPHA_NUM 1
+
+/* PowerPC specific declarations */
+
+/* Values for Elf32/64_Ehdr.e_flags. */
+#define EF_PPC_EMB 0x80000000 /* PowerPC embedded flag */
+
+/* Cygnus local bits below */
+#define EF_PPC_RELOCATABLE 0x00010000 /* PowerPC -mrelocatable flag*/
+#define EF_PPC_RELOCATABLE_LIB 0x00008000 /* PowerPC -mrelocatable-lib
+ flag */
+
+/* PowerPC relocations defined by the ABIs */
+#define R_PPC_NONE 0
+#define R_PPC_ADDR32 1 /* 32bit absolute address */
+#define R_PPC_ADDR24 2 /* 26bit address, 2 bits ignored. */
+#define R_PPC_ADDR16 3 /* 16bit absolute address */
+#define R_PPC_ADDR16_LO 4 /* lower 16bit of absolute address */
+#define R_PPC_ADDR16_HI 5 /* high 16bit of absolute address */
+#define R_PPC_ADDR16_HA 6 /* adjusted high 16bit */
+#define R_PPC_ADDR14 7 /* 16bit address, 2 bits ignored */
+#define R_PPC_ADDR14_BRTAKEN 8
+#define R_PPC_ADDR14_BRNTAKEN 9
+#define R_PPC_REL24 10 /* PC relative 26 bit */
+#define R_PPC_REL14 11 /* PC relative 16 bit */
+#define R_PPC_REL14_BRTAKEN 12
+#define R_PPC_REL14_BRNTAKEN 13
+#define R_PPC_GOT16 14
+#define R_PPC_GOT16_LO 15
+#define R_PPC_GOT16_HI 16
+#define R_PPC_GOT16_HA 17
+#define R_PPC_PLTREL24 18
+#define R_PPC_COPY 19
+#define R_PPC_GLOB_DAT 20
+#define R_PPC_JMP_SLOT 21
+#define R_PPC_RELATIVE 22
+#define R_PPC_LOCAL24PC 23
+#define R_PPC_UADDR32 24
+#define R_PPC_UADDR16 25
+#define R_PPC_REL32 26
+#define R_PPC_PLT32 27
+#define R_PPC_PLTREL32 28
+#define R_PPC_PLT16_LO 29
+#define R_PPC_PLT16_HI 30
+#define R_PPC_PLT16_HA 31
+#define R_PPC_SDAREL16 32
+#define R_PPC_SECTOFF 33
+#define R_PPC_SECTOFF_LO 34
+#define R_PPC_SECTOFF_HI 35
+#define R_PPC_SECTOFF_HA 36
+
+/* PowerPC relocations defined for the TLS access ABI. */
+#define R_PPC_TLS 67 /* none (sym+add)@tls */
+#define R_PPC_DTPMOD32 68 /* word32 (sym+add)@dtpmod */
+#define R_PPC_TPREL16 69 /* half16* (sym+add)@tprel */
+#define R_PPC_TPREL16_LO 70 /* half16 (sym+add)@tprel@l */
+#define R_PPC_TPREL16_HI 71 /* half16 (sym+add)@tprel@h */
+#define R_PPC_TPREL16_HA 72 /* half16 (sym+add)@tprel@ha */
+#define R_PPC_TPREL32 73 /* word32 (sym+add)@tprel */
+#define R_PPC_DTPREL16 74 /* half16* (sym+add)@dtprel */
+#define R_PPC_DTPREL16_LO 75 /* half16 (sym+add)@dtprel@l */
+#define R_PPC_DTPREL16_HI 76 /* half16 (sym+add)@dtprel@h */
+#define R_PPC_DTPREL16_HA 77 /* half16 (sym+add)@dtprel@ha */
+#define R_PPC_DTPREL32 78 /* word32 (sym+add)@dtprel */
+#define R_PPC_GOT_TLSGD16 79 /* half16* (sym+add)@got@tlsgd */
+#define R_PPC_GOT_TLSGD16_LO 80 /* half16 (sym+add)@got@tlsgd@l */
+#define R_PPC_GOT_TLSGD16_HI 81 /* half16 (sym+add)@got@tlsgd@h */
+#define R_PPC_GOT_TLSGD16_HA 82 /* half16 (sym+add)@got@tlsgd@ha */
+#define R_PPC_GOT_TLSLD16 83 /* half16* (sym+add)@got@tlsld */
+#define R_PPC_GOT_TLSLD16_LO 84 /* half16 (sym+add)@got@tlsld@l */
+#define R_PPC_GOT_TLSLD16_HI 85 /* half16 (sym+add)@got@tlsld@h */
+#define R_PPC_GOT_TLSLD16_HA 86 /* half16 (sym+add)@got@tlsld@ha */
+#define R_PPC_GOT_TPREL16 87 /* half16* (sym+add)@got@tprel */
+#define R_PPC_GOT_TPREL16_LO 88 /* half16 (sym+add)@got@tprel@l */
+#define R_PPC_GOT_TPREL16_HI 89 /* half16 (sym+add)@got@tprel@h */
+#define R_PPC_GOT_TPREL16_HA 90 /* half16 (sym+add)@got@tprel@ha */
+#define R_PPC_GOT_DTPREL16 91 /* half16* (sym+add)@got@dtprel */
+#define R_PPC_GOT_DTPREL16_LO 92 /* half16* (sym+add)@got@dtprel@l */
+#define R_PPC_GOT_DTPREL16_HI 93 /* half16* (sym+add)@got@dtprel@h */
+#define R_PPC_GOT_DTPREL16_HA 94 /* half16* (sym+add)@got@dtprel@ha */
+
+/* Keep this the last entry. */
+#define R_PPC_NUM 95
+
+/* The remaining relocs are from the Embedded ELF ABI, and are not
+ in the SVR4 ELF ABI. */
+#define R_PPC_EMB_NADDR32 101
+#define R_PPC_EMB_NADDR16 102
+#define R_PPC_EMB_NADDR16_LO 103
+#define R_PPC_EMB_NADDR16_HI 104
+#define R_PPC_EMB_NADDR16_HA 105
+#define R_PPC_EMB_SDAI16 106
+#define R_PPC_EMB_SDA2I16 107
+#define R_PPC_EMB_SDA2REL 108
+#define R_PPC_EMB_SDA21 109 /* 16 bit offset in SDA */
+#define R_PPC_EMB_MRKREF 110
+#define R_PPC_EMB_RELSEC16 111
+#define R_PPC_EMB_RELST_LO 112
+#define R_PPC_EMB_RELST_HI 113
+#define R_PPC_EMB_RELST_HA 114
+#define R_PPC_EMB_BIT_FLD 115
+#define R_PPC_EMB_RELSDA 116 /* 16 bit relative offset in SDA */
+
+/* Diab tool relocations. */
+#define R_PPC_DIAB_SDA21_LO 180 /* like EMB_SDA21, but lower 16 bit */
+#define R_PPC_DIAB_SDA21_HI 181 /* like EMB_SDA21, but high 16 bit */
+#define R_PPC_DIAB_SDA21_HA 182 /* like EMB_SDA21, adjusted high 16 */
+#define R_PPC_DIAB_RELSDA_LO 183 /* like EMB_RELSDA, but lower 16 bit */
+#define R_PPC_DIAB_RELSDA_HI 184 /* like EMB_RELSDA, but high 16 bit */
+#define R_PPC_DIAB_RELSDA_HA 185 /* like EMB_RELSDA, adjusted high 16 */
+
+/* GNU relocs used in PIC code sequences. */
+#define R_PPC_REL16 249 /* word32 (sym-.) */
+#define R_PPC_REL16_LO 250 /* half16 (sym-.)@l */
+#define R_PPC_REL16_HI 251 /* half16 (sym-.)@h */
+#define R_PPC_REL16_HA 252 /* half16 (sym-.)@ha */
+
+/* This is a phony reloc to handle any old fashioned TOC16 references
+ that may still be in object files. */
+#define R_PPC_TOC16 255
+
+/* PowerPC specific values for the Dyn d_tag field. */
+#define DT_PPC_GOT (DT_LOPROC + 0)
+#define DT_PPC_NUM 1
+
+/* PowerPC64 relocations defined by the ABIs */
+#define R_PPC64_NONE R_PPC_NONE
+#define R_PPC64_ADDR32 R_PPC_ADDR32 /* 32bit absolute address */
+#define R_PPC64_ADDR24 R_PPC_ADDR24 /* 26bit address, word aligned */
+#define R_PPC64_ADDR16 R_PPC_ADDR16 /* 16bit absolute address */
+#define R_PPC64_ADDR16_LO R_PPC_ADDR16_LO /* lower 16bits of address */
+#define R_PPC64_ADDR16_HI R_PPC_ADDR16_HI /* high 16bits of address. */
+#define R_PPC64_ADDR16_HA R_PPC_ADDR16_HA /* adjusted high 16bits. */
+#define R_PPC64_ADDR14 R_PPC_ADDR14 /* 16bit address, word aligned */
+#define R_PPC64_ADDR14_BRTAKEN R_PPC_ADDR14_BRTAKEN
+#define R_PPC64_ADDR14_BRNTAKEN R_PPC_ADDR14_BRNTAKEN
+#define R_PPC64_REL24 R_PPC_REL24 /* PC-rel. 26 bit, word aligned */
+#define R_PPC64_REL14 R_PPC_REL14 /* PC relative 16 bit */
+#define R_PPC64_REL14_BRTAKEN R_PPC_REL14_BRTAKEN
+#define R_PPC64_REL14_BRNTAKEN R_PPC_REL14_BRNTAKEN
+#define R_PPC64_GOT16 R_PPC_GOT16
+#define R_PPC64_GOT16_LO R_PPC_GOT16_LO
+#define R_PPC64_GOT16_HI R_PPC_GOT16_HI
+#define R_PPC64_GOT16_HA R_PPC_GOT16_HA
+
+#define R_PPC64_COPY R_PPC_COPY
+#define R_PPC64_GLOB_DAT R_PPC_GLOB_DAT
+#define R_PPC64_JMP_SLOT R_PPC_JMP_SLOT
+#define R_PPC64_RELATIVE R_PPC_RELATIVE
+
+#define R_PPC64_UADDR32 R_PPC_UADDR32
+#define R_PPC64_UADDR16 R_PPC_UADDR16
+#define R_PPC64_REL32 R_PPC_REL32
+#define R_PPC64_PLT32 R_PPC_PLT32
+#define R_PPC64_PLTREL32 R_PPC_PLTREL32
+#define R_PPC64_PLT16_LO R_PPC_PLT16_LO
+#define R_PPC64_PLT16_HI R_PPC_PLT16_HI
+#define R_PPC64_PLT16_HA R_PPC_PLT16_HA
+
+#define R_PPC64_SECTOFF R_PPC_SECTOFF
+#define R_PPC64_SECTOFF_LO R_PPC_SECTOFF_LO
+#define R_PPC64_SECTOFF_HI R_PPC_SECTOFF_HI
+#define R_PPC64_SECTOFF_HA R_PPC_SECTOFF_HA
+#define R_PPC64_ADDR30 37 /* word30 (S + A - P) >> 2 */
+#define R_PPC64_ADDR64 38 /* doubleword64 S + A */
+#define R_PPC64_ADDR16_HIGHER 39 /* half16 #higher(S + A) */
+#define R_PPC64_ADDR16_HIGHERA 40 /* half16 #highera(S + A) */
+#define R_PPC64_ADDR16_HIGHEST 41 /* half16 #highest(S + A) */
+#define R_PPC64_ADDR16_HIGHESTA 42 /* half16 #highesta(S + A) */
+#define R_PPC64_UADDR64 43 /* doubleword64 S + A */
+#define R_PPC64_REL64 44 /* doubleword64 S + A - P */
+#define R_PPC64_PLT64 45 /* doubleword64 L + A */
+#define R_PPC64_PLTREL64 46 /* doubleword64 L + A - P */
+#define R_PPC64_TOC16 47 /* half16* S + A - .TOC */
+#define R_PPC64_TOC16_LO 48 /* half16 #lo(S + A - .TOC.) */
+#define R_PPC64_TOC16_HI 49 /* half16 #hi(S + A - .TOC.) */
+#define R_PPC64_TOC16_HA 50 /* half16 #ha(S + A - .TOC.) */
+#define R_PPC64_TOC 51 /* doubleword64 .TOC */
+#define R_PPC64_PLTGOT16 52 /* half16* M + A */
+#define R_PPC64_PLTGOT16_LO 53 /* half16 #lo(M + A) */
+#define R_PPC64_PLTGOT16_HI 54 /* half16 #hi(M + A) */
+#define R_PPC64_PLTGOT16_HA 55 /* half16 #ha(M + A) */
+
+#define R_PPC64_ADDR16_DS 56 /* half16ds* (S + A) >> 2 */
+#define R_PPC64_ADDR16_LO_DS 57 /* half16ds #lo(S + A) >> 2 */
+#define R_PPC64_GOT16_DS 58 /* half16ds* (G + A) >> 2 */
+#define R_PPC64_GOT16_LO_DS 59 /* half16ds #lo(G + A) >> 2 */
+#define R_PPC64_PLT16_LO_DS 60 /* half16ds #lo(L + A) >> 2 */
+#define R_PPC64_SECTOFF_DS 61 /* half16ds* (R + A) >> 2 */
+#define R_PPC64_SECTOFF_LO_DS 62 /* half16ds #lo(R + A) >> 2 */
+#define R_PPC64_TOC16_DS 63 /* half16ds* (S + A - .TOC.) >> 2 */
+#define R_PPC64_TOC16_LO_DS 64 /* half16ds #lo(S + A - .TOC.) >> 2 */
+#define R_PPC64_PLTGOT16_DS 65 /* half16ds* (M + A) >> 2 */
+#define R_PPC64_PLTGOT16_LO_DS 66 /* half16ds #lo(M + A) >> 2 */
+
+/* PowerPC64 relocations defined for the TLS access ABI. */
+#define R_PPC64_TLS 67 /* none (sym+add)@tls */
+#define R_PPC64_DTPMOD64 68 /* doubleword64 (sym+add)@dtpmod */
+#define R_PPC64_TPREL16 69 /* half16* (sym+add)@tprel */
+#define R_PPC64_TPREL16_LO 70 /* half16 (sym+add)@tprel@l */
+#define R_PPC64_TPREL16_HI 71 /* half16 (sym+add)@tprel@h */
+#define R_PPC64_TPREL16_HA 72 /* half16 (sym+add)@tprel@ha */
+#define R_PPC64_TPREL64 73 /* doubleword64 (sym+add)@tprel */
+#define R_PPC64_DTPREL16 74 /* half16* (sym+add)@dtprel */
+#define R_PPC64_DTPREL16_LO 75 /* half16 (sym+add)@dtprel@l */
+#define R_PPC64_DTPREL16_HI 76 /* half16 (sym+add)@dtprel@h */
+#define R_PPC64_DTPREL16_HA 77 /* half16 (sym+add)@dtprel@ha */
+#define R_PPC64_DTPREL64 78 /* doubleword64 (sym+add)@dtprel */
+#define R_PPC64_GOT_TLSGD16 79 /* half16* (sym+add)@got@tlsgd */
+#define R_PPC64_GOT_TLSGD16_LO 80 /* half16 (sym+add)@got@tlsgd@l */
+#define R_PPC64_GOT_TLSGD16_HI 81 /* half16 (sym+add)@got@tlsgd@h */
+#define R_PPC64_GOT_TLSGD16_HA 82 /* half16 (sym+add)@got@tlsgd@ha */
+#define R_PPC64_GOT_TLSLD16 83 /* half16* (sym+add)@got@tlsld */
+#define R_PPC64_GOT_TLSLD16_LO 84 /* half16 (sym+add)@got@tlsld@l */
+#define R_PPC64_GOT_TLSLD16_HI 85 /* half16 (sym+add)@got@tlsld@h */
+#define R_PPC64_GOT_TLSLD16_HA 86 /* half16 (sym+add)@got@tlsld@ha */
+#define R_PPC64_GOT_TPREL16_DS 87 /* half16ds* (sym+add)@got@tprel */
+#define R_PPC64_GOT_TPREL16_LO_DS 88 /* half16ds (sym+add)@got@tprel@l */
+#define R_PPC64_GOT_TPREL16_HI 89 /* half16 (sym+add)@got@tprel@h */
+#define R_PPC64_GOT_TPREL16_HA 90 /* half16 (sym+add)@got@tprel@ha */
+#define R_PPC64_GOT_DTPREL16_DS 91 /* half16ds* (sym+add)@got@dtprel */
+#define R_PPC64_GOT_DTPREL16_LO_DS 92 /* half16ds (sym+add)@got@dtprel@l */
+#define R_PPC64_GOT_DTPREL16_HI 93 /* half16 (sym+add)@got@dtprel@h */
+#define R_PPC64_GOT_DTPREL16_HA 94 /* half16 (sym+add)@got@dtprel@ha */
+#define R_PPC64_TPREL16_DS 95 /* half16ds* (sym+add)@tprel */
+#define R_PPC64_TPREL16_LO_DS 96 /* half16ds (sym+add)@tprel@l */
+#define R_PPC64_TPREL16_HIGHER 97 /* half16 (sym+add)@tprel@higher */
+#define R_PPC64_TPREL16_HIGHERA 98 /* half16 (sym+add)@tprel@highera */
+#define R_PPC64_TPREL16_HIGHEST 99 /* half16 (sym+add)@tprel@highest */
+#define R_PPC64_TPREL16_HIGHESTA 100 /* half16 (sym+add)@tprel@highesta */
+#define R_PPC64_DTPREL16_DS 101 /* half16ds* (sym+add)@dtprel */
+#define R_PPC64_DTPREL16_LO_DS 102 /* half16ds (sym+add)@dtprel@l */
+#define R_PPC64_DTPREL16_HIGHER 103 /* half16 (sym+add)@dtprel@higher */
+#define R_PPC64_DTPREL16_HIGHERA 104 /* half16 (sym+add)@dtprel@highera */
+#define R_PPC64_DTPREL16_HIGHEST 105 /* half16 (sym+add)@dtprel@highest */
+#define R_PPC64_DTPREL16_HIGHESTA 106 /* half16 (sym+add)@dtprel@highesta */
+
+/* Keep this the last entry. */
+#define R_PPC64_NUM 107
+
+/* PowerPC64 specific values for the Dyn d_tag field. */
+#define DT_PPC64_GLINK (DT_LOPROC + 0)
+#define DT_PPC64_OPD (DT_LOPROC + 1)
+#define DT_PPC64_OPDSZ (DT_LOPROC + 2)
+#define DT_PPC64_NUM 3
+
+
+/* ARM specific declarations */
+
+/* Processor specific flags for the ELF header e_flags field. */
+#define EF_ARM_RELEXEC 0x01
+#define EF_ARM_HASENTRY 0x02
+#define EF_ARM_INTERWORK 0x04
+#define EF_ARM_APCS_26 0x08
+#define EF_ARM_APCS_FLOAT 0x10
+#define EF_ARM_PIC 0x20
+#define EF_ARM_ALIGN8 0x40 /* 8-bit structure alignment is in use */
+#define EF_ARM_NEW_ABI 0x80
+#define EF_ARM_OLD_ABI 0x100
+
+/* Other constants defined in the ARM ELF spec. version B-01. */
+/* NB. These conflict with values defined above. */
+#define EF_ARM_SYMSARESORTED 0x04
+#define EF_ARM_DYNSYMSUSESEGIDX 0x08
+#define EF_ARM_MAPSYMSFIRST 0x10
+#define EF_ARM_EABIMASK 0XFF000000
+
+#define EF_ARM_EABI_VERSION(flags) ((flags) & EF_ARM_EABIMASK)
+#define EF_ARM_EABI_UNKNOWN 0x00000000
+#define EF_ARM_EABI_VER1 0x01000000
+#define EF_ARM_EABI_VER2 0x02000000
+
+/* Additional symbol types for Thumb */
+#define STT_ARM_TFUNC 0xd
+
+/* ARM-specific values for sh_flags */
+#define SHF_ARM_ENTRYSECT 0x10000000 /* Section contains an entry point */
+#define SHF_ARM_COMDEF 0x80000000 /* Section may be multiply defined
+ in the input to a link step */
+
+/* ARM-specific program header flags */
+#define PF_ARM_SB 0x10000000 /* Segment contains the location
+ addressed by the static base */
+
+/* Processor specific values for the Phdr p_type field. */
+#define PT_ARM_EXIDX 0x70000001 /* .ARM.exidx segment */
+
+/* ARM relocs. */
+
+#define R_ARM_NONE 0 /* No reloc */
+#define R_ARM_PC24 1 /* PC relative 26 bit branch */
+#define R_ARM_ABS32 2 /* Direct 32 bit */
+#define R_ARM_REL32 3 /* PC relative 32 bit */
+#define R_ARM_PC13 4
+#define R_ARM_ABS16 5 /* Direct 16 bit */
+#define R_ARM_ABS12 6 /* Direct 12 bit */
+#define R_ARM_THM_ABS5 7
+#define R_ARM_ABS8 8 /* Direct 8 bit */
+#define R_ARM_SBREL32 9
+#define R_ARM_THM_PC22 10
+#define R_ARM_THM_PC8 11
+#define R_ARM_AMP_VCALL9 12
+#define R_ARM_SWI24 13
+#define R_ARM_THM_SWI8 14
+#define R_ARM_XPC25 15
+#define R_ARM_THM_XPC22 16
+#define R_ARM_TLS_DTPMOD32 17 /* ID of module containing symbol */
+#define R_ARM_TLS_DTPOFF32 18 /* Offset in TLS block */
+#define R_ARM_TLS_TPOFF32 19 /* Offset in static TLS block */
+#define R_ARM_COPY 20 /* Copy symbol at runtime */
+#define R_ARM_GLOB_DAT 21 /* Create GOT entry */
+#define R_ARM_JUMP_SLOT 22 /* Create PLT entry */
+#define R_ARM_RELATIVE 23 /* Adjust by program base */
+#define R_ARM_GOTOFF 24 /* 32 bit offset to GOT */
+#define R_ARM_GOTPC 25 /* 32 bit PC relative offset to GOT */
+#define R_ARM_GOT32 26 /* 32 bit GOT entry */
+#define R_ARM_PLT32 27 /* 32 bit PLT address */
+#define R_ARM_ALU_PCREL_7_0 32
+#define R_ARM_ALU_PCREL_15_8 33
+#define R_ARM_ALU_PCREL_23_15 34
+#define R_ARM_LDR_SBREL_11_0 35
+#define R_ARM_ALU_SBREL_19_12 36
+#define R_ARM_ALU_SBREL_27_20 37
+#define R_ARM_GNU_VTENTRY 100
+#define R_ARM_GNU_VTINHERIT 101
+#define R_ARM_THM_PC11 102 /* thumb unconditional branch */
+#define R_ARM_THM_PC9 103 /* thumb conditional branch */
+#define R_ARM_TLS_GD32 104 /* PC-rel 32 bit for global dynamic
+ thread local data */
+#define R_ARM_TLS_LDM32 105 /* PC-rel 32 bit for local dynamic
+ thread local data */
+#define R_ARM_TLS_LDO32 106 /* 32 bit offset relative to TLS
+ block */
+#define R_ARM_TLS_IE32 107 /* PC-rel 32 bit for GOT entry of
+ static TLS block offset */
+#define R_ARM_TLS_LE32 108 /* 32 bit offset relative to static
+ TLS block */
+#define R_ARM_RXPC25 249
+#define R_ARM_RSBREL32 250
+#define R_ARM_THM_RPC22 251
+#define R_ARM_RREL32 252
+#define R_ARM_RABS22 253
+#define R_ARM_RPC24 254
+#define R_ARM_RBASE 255
+/* Keep this the last entry. */
+#define R_ARM_NUM 256
+
+/* IA-64 specific declarations. */
+
+/* Processor specific flags for the Ehdr e_flags field. */
+#define EF_IA_64_MASKOS 0x0000000f /* os-specific flags */
+#define EF_IA_64_ABI64 0x00000010 /* 64-bit ABI */
+#define EF_IA_64_ARCH 0xff000000 /* arch. version mask */
+
+/* Processor specific values for the Phdr p_type field. */
+#define PT_IA_64_ARCHEXT (PT_LOPROC + 0) /* arch extension bits */
+#define PT_IA_64_UNWIND (PT_LOPROC + 1) /* ia64 unwind bits */
+#define PT_IA_64_HP_OPT_ANOT (PT_LOOS + 0x12)
+#define PT_IA_64_HP_HSL_ANOT (PT_LOOS + 0x13)
+#define PT_IA_64_HP_STACK (PT_LOOS + 0x14)
+
+/* Processor specific flags for the Phdr p_flags field. */
+#define PF_IA_64_NORECOV 0x80000000 /* spec insns w/o recovery */
+
+/* Processor specific values for the Shdr sh_type field. */
+#define SHT_IA_64_EXT (SHT_LOPROC + 0) /* extension bits */
+#define SHT_IA_64_UNWIND (SHT_LOPROC + 1) /* unwind bits */
+
+/* Processor specific flags for the Shdr sh_flags field. */
+#define SHF_IA_64_SHORT 0x10000000 /* section near gp */
+#define SHF_IA_64_NORECOV 0x20000000 /* spec insns w/o recovery */
+
+/* Processor specific values for the Dyn d_tag field. */
+#define DT_IA_64_PLT_RESERVE (DT_LOPROC + 0)
+#define DT_IA_64_NUM 1
+
+/* IA-64 relocations. */
+#define R_IA64_NONE 0x00 /* none */
+#define R_IA64_IMM14 0x21 /* symbol + addend, add imm14 */
+#define R_IA64_IMM22 0x22 /* symbol + addend, add imm22 */
+#define R_IA64_IMM64 0x23 /* symbol + addend, mov imm64 */
+#define R_IA64_DIR32MSB 0x24 /* symbol + addend, data4 MSB */
+#define R_IA64_DIR32LSB 0x25 /* symbol + addend, data4 LSB */
+#define R_IA64_DIR64MSB 0x26 /* symbol + addend, data8 MSB */
+#define R_IA64_DIR64LSB 0x27 /* symbol + addend, data8 LSB */
+#define R_IA64_GPREL22 0x2a /* @gprel(sym + add), add imm22 */
+#define R_IA64_GPREL64I 0x2b /* @gprel(sym + add), mov imm64 */
+#define R_IA64_GPREL32MSB 0x2c /* @gprel(sym + add), data4 MSB */
+#define R_IA64_GPREL32LSB 0x2d /* @gprel(sym + add), data4 LSB */
+#define R_IA64_GPREL64MSB 0x2e /* @gprel(sym + add), data8 MSB */
+#define R_IA64_GPREL64LSB 0x2f /* @gprel(sym + add), data8 LSB */
+#define R_IA64_LTOFF22 0x32 /* @ltoff(sym + add), add imm22 */
+#define R_IA64_LTOFF64I 0x33 /* @ltoff(sym + add), mov imm64 */
+#define R_IA64_PLTOFF22 0x3a /* @pltoff(sym + add), add imm22 */
+#define R_IA64_PLTOFF64I 0x3b /* @pltoff(sym + add), mov imm64 */
+#define R_IA64_PLTOFF64MSB 0x3e /* @pltoff(sym + add), data8 MSB */
+#define R_IA64_PLTOFF64LSB 0x3f /* @pltoff(sym + add), data8 LSB */
+#define R_IA64_FPTR64I 0x43 /* @fptr(sym + add), mov imm64 */
+#define R_IA64_FPTR32MSB 0x44 /* @fptr(sym + add), data4 MSB */
+#define R_IA64_FPTR32LSB 0x45 /* @fptr(sym + add), data4 LSB */
+#define R_IA64_FPTR64MSB 0x46 /* @fptr(sym + add), data8 MSB */
+#define R_IA64_FPTR64LSB 0x47 /* @fptr(sym + add), data8 LSB */
+#define R_IA64_PCREL60B 0x48 /* @pcrel(sym + add), brl */
+#define R_IA64_PCREL21B 0x49 /* @pcrel(sym + add), ptb, call */
+#define R_IA64_PCREL21M 0x4a /* @pcrel(sym + add), chk.s */
+#define R_IA64_PCREL21F 0x4b /* @pcrel(sym + add), fchkf */
+#define R_IA64_PCREL32MSB 0x4c /* @pcrel(sym + add), data4 MSB */
+#define R_IA64_PCREL32LSB 0x4d /* @pcrel(sym + add), data4 LSB */
+#define R_IA64_PCREL64MSB 0x4e /* @pcrel(sym + add), data8 MSB */
+#define R_IA64_PCREL64LSB 0x4f /* @pcrel(sym + add), data8 LSB */
+#define R_IA64_LTOFF_FPTR22 0x52 /* @ltoff(@fptr(s+a)), imm22 */
+#define R_IA64_LTOFF_FPTR64I 0x53 /* @ltoff(@fptr(s+a)), imm64 */
+#define R_IA64_LTOFF_FPTR32MSB 0x54 /* @ltoff(@fptr(s+a)), data4 MSB */
+#define R_IA64_LTOFF_FPTR32LSB 0x55 /* @ltoff(@fptr(s+a)), data4 LSB */
+#define R_IA64_LTOFF_FPTR64MSB 0x56 /* @ltoff(@fptr(s+a)), data8 MSB */
+#define R_IA64_LTOFF_FPTR64LSB 0x57 /* @ltoff(@fptr(s+a)), data8 LSB */
+#define R_IA64_SEGREL32MSB 0x5c /* @segrel(sym + add), data4 MSB */
+#define R_IA64_SEGREL32LSB 0x5d /* @segrel(sym + add), data4 LSB */
+#define R_IA64_SEGREL64MSB 0x5e /* @segrel(sym + add), data8 MSB */
+#define R_IA64_SEGREL64LSB 0x5f /* @segrel(sym + add), data8 LSB */
+#define R_IA64_SECREL32MSB 0x64 /* @secrel(sym + add), data4 MSB */
+#define R_IA64_SECREL32LSB 0x65 /* @secrel(sym + add), data4 LSB */
+#define R_IA64_SECREL64MSB 0x66 /* @secrel(sym + add), data8 MSB */
+#define R_IA64_SECREL64LSB 0x67 /* @secrel(sym + add), data8 LSB */
+#define R_IA64_REL32MSB 0x6c /* data 4 + REL */
+#define R_IA64_REL32LSB 0x6d /* data 4 + REL */
+#define R_IA64_REL64MSB 0x6e /* data 8 + REL */
+#define R_IA64_REL64LSB 0x6f /* data 8 + REL */
+#define R_IA64_LTV32MSB 0x74 /* symbol + addend, data4 MSB */
+#define R_IA64_LTV32LSB 0x75 /* symbol + addend, data4 LSB */
+#define R_IA64_LTV64MSB 0x76 /* symbol + addend, data8 MSB */
+#define R_IA64_LTV64LSB 0x77 /* symbol + addend, data8 LSB */
+#define R_IA64_PCREL21BI 0x79 /* @pcrel(sym + add), 21bit inst */
+#define R_IA64_PCREL22 0x7a /* @pcrel(sym + add), 22bit inst */
+#define R_IA64_PCREL64I 0x7b /* @pcrel(sym + add), 64bit inst */
+#define R_IA64_IPLTMSB 0x80 /* dynamic reloc, imported PLT, MSB */
+#define R_IA64_IPLTLSB 0x81 /* dynamic reloc, imported PLT, LSB */
+#define R_IA64_COPY 0x84 /* copy relocation */
+#define R_IA64_SUB 0x85 /* Addend and symbol difference */
+#define R_IA64_LTOFF22X 0x86 /* LTOFF22, relaxable. */
+#define R_IA64_LDXMOV 0x87 /* Use of LTOFF22X. */
+#define R_IA64_TPREL14 0x91 /* @tprel(sym + add), imm14 */
+#define R_IA64_TPREL22 0x92 /* @tprel(sym + add), imm22 */
+#define R_IA64_TPREL64I 0x93 /* @tprel(sym + add), imm64 */
+#define R_IA64_TPREL64MSB 0x96 /* @tprel(sym + add), data8 MSB */
+#define R_IA64_TPREL64LSB 0x97 /* @tprel(sym + add), data8 LSB */
+#define R_IA64_LTOFF_TPREL22 0x9a /* @ltoff(@tprel(s+a)), imm2 */
+#define R_IA64_DTPMOD64MSB 0xa6 /* @dtpmod(sym + add), data8 MSB */
+#define R_IA64_DTPMOD64LSB 0xa7 /* @dtpmod(sym + add), data8 LSB */
+#define R_IA64_LTOFF_DTPMOD22 0xaa /* @ltoff(@dtpmod(sym + add)), imm22 */
+#define R_IA64_DTPREL14 0xb1 /* @dtprel(sym + add), imm14 */
+#define R_IA64_DTPREL22 0xb2 /* @dtprel(sym + add), imm22 */
+#define R_IA64_DTPREL64I 0xb3 /* @dtprel(sym + add), imm64 */
+#define R_IA64_DTPREL32MSB 0xb4 /* @dtprel(sym + add), data4 MSB */
+#define R_IA64_DTPREL32LSB 0xb5 /* @dtprel(sym + add), data4 LSB */
+#define R_IA64_DTPREL64MSB 0xb6 /* @dtprel(sym + add), data8 MSB */
+#define R_IA64_DTPREL64LSB 0xb7 /* @dtprel(sym + add), data8 LSB */
+#define R_IA64_LTOFF_DTPREL22 0xba /* @ltoff(@dtprel(s+a)), imm22 */
+
+/* SH specific declarations */
+
+/* SH relocs. */
+#define R_SH_NONE 0
+#define R_SH_DIR32 1
+#define R_SH_REL32 2
+#define R_SH_DIR8WPN 3
+#define R_SH_IND12W 4
+#define R_SH_DIR8WPL 5
+#define R_SH_DIR8WPZ 6
+#define R_SH_DIR8BP 7
+#define R_SH_DIR8W 8
+#define R_SH_DIR8L 9
+#define R_SH_SWITCH16 25
+#define R_SH_SWITCH32 26
+#define R_SH_USES 27
+#define R_SH_COUNT 28
+#define R_SH_ALIGN 29
+#define R_SH_CODE 30
+#define R_SH_DATA 31
+#define R_SH_LABEL 32
+#define R_SH_SWITCH8 33
+#define R_SH_GNU_VTINHERIT 34
+#define R_SH_GNU_VTENTRY 35
+#define R_SH_TLS_GD_32 144
+#define R_SH_TLS_LD_32 145
+#define R_SH_TLS_LDO_32 146
+#define R_SH_TLS_IE_32 147
+#define R_SH_TLS_LE_32 148
+#define R_SH_TLS_DTPMOD32 149
+#define R_SH_TLS_DTPOFF32 150
+#define R_SH_TLS_TPOFF32 151
+#define R_SH_GOT32 160
+#define R_SH_PLT32 161
+#define R_SH_COPY 162
+#define R_SH_GLOB_DAT 163
+#define R_SH_JMP_SLOT 164
+#define R_SH_RELATIVE 165
+#define R_SH_GOTOFF 166
+#define R_SH_GOTPC 167
+/* Keep this the last entry. */
+#define R_SH_NUM 256
+
+/* Additional s390 relocs */
+
+#define R_390_NONE 0 /* No reloc. */
+#define R_390_8 1 /* Direct 8 bit. */
+#define R_390_12 2 /* Direct 12 bit. */
+#define R_390_16 3 /* Direct 16 bit. */
+#define R_390_32 4 /* Direct 32 bit. */
+#define R_390_PC32 5 /* PC relative 32 bit. */
+#define R_390_GOT12 6 /* 12 bit GOT offset. */
+#define R_390_GOT32 7 /* 32 bit GOT offset. */
+#define R_390_PLT32 8 /* 32 bit PC relative PLT address. */
+#define R_390_COPY 9 /* Copy symbol at runtime. */
+#define R_390_GLOB_DAT 10 /* Create GOT entry. */
+#define R_390_JMP_SLOT 11 /* Create PLT entry. */
+#define R_390_RELATIVE 12 /* Adjust by program base. */
+#define R_390_GOTOFF32 13 /* 32 bit offset to GOT. */
+#define R_390_GOTPC 14 /* 32 bit PC relative offset to GOT. */
+#define R_390_GOT16 15 /* 16 bit GOT offset. */
+#define R_390_PC16 16 /* PC relative 16 bit. */
+#define R_390_PC16DBL 17 /* PC relative 16 bit shifted by 1. */
+#define R_390_PLT16DBL 18 /* 16 bit PC rel. PLT shifted by 1. */
+#define R_390_PC32DBL 19 /* PC relative 32 bit shifted by 1. */
+#define R_390_PLT32DBL 20 /* 32 bit PC rel. PLT shifted by 1. */
+#define R_390_GOTPCDBL 21 /* 32 bit PC rel. GOT shifted by 1. */
+#define R_390_64 22 /* Direct 64 bit. */
+#define R_390_PC64 23 /* PC relative 64 bit. */
+#define R_390_GOT64 24 /* 64 bit GOT offset. */
+#define R_390_PLT64 25 /* 64 bit PC relative PLT address. */
+#define R_390_GOTENT 26 /* 32 bit PC rel. to GOT entry >> 1. */
+#define R_390_GOTOFF16 27 /* 16 bit offset to GOT. */
+#define R_390_GOTOFF64 28 /* 64 bit offset to GOT. */
+#define R_390_GOTPLT12 29 /* 12 bit offset to jump slot. */
+#define R_390_GOTPLT16 30 /* 16 bit offset to jump slot. */
+#define R_390_GOTPLT32 31 /* 32 bit offset to jump slot. */
+#define R_390_GOTPLT64 32 /* 64 bit offset to jump slot. */
+#define R_390_GOTPLTENT 33 /* 32 bit rel. offset to jump slot. */
+#define R_390_PLTOFF16 34 /* 16 bit offset from GOT to PLT. */
+#define R_390_PLTOFF32 35 /* 32 bit offset from GOT to PLT. */
+#define R_390_PLTOFF64 36 /* 16 bit offset from GOT to PLT. */
+#define R_390_TLS_LOAD 37 /* Tag for load insn in TLS code. */
+#define R_390_TLS_GDCALL 38 /* Tag for function call in general
+ dynamic TLS code. */
+#define R_390_TLS_LDCALL 39 /* Tag for function call in local
+ dynamic TLS code. */
+#define R_390_TLS_GD32 40 /* Direct 32 bit for general dynamic
+ thread local data. */
+#define R_390_TLS_GD64 41 /* Direct 64 bit for general dynamic
+ thread local data. */
+#define R_390_TLS_GOTIE12 42 /* 12 bit GOT offset for static TLS
+ block offset. */
+#define R_390_TLS_GOTIE32 43 /* 32 bit GOT offset for static TLS
+ block offset. */
+#define R_390_TLS_GOTIE64 44 /* 64 bit GOT offset for static TLS
+ block offset. */
+#define R_390_TLS_LDM32 45 /* Direct 32 bit for local dynamic
+ thread local data in LE code. */
+#define R_390_TLS_LDM64 46 /* Direct 64 bit for local dynamic
+ thread local data in LE code. */
+#define R_390_TLS_IE32 47 /* 32 bit address of GOT entry for
+ negated static TLS block offset. */
+#define R_390_TLS_IE64 48 /* 64 bit address of GOT entry for
+ negated static TLS block offset. */
+#define R_390_TLS_IEENT 49 /* 32 bit rel. offset to GOT entry for
+ negated static TLS block offset. */
+#define R_390_TLS_LE32 50 /* 32 bit negated offset relative to
+ static TLS block. */
+#define R_390_TLS_LE64 51 /* 64 bit negated offset relative to
+ static TLS block. */
+#define R_390_TLS_LDO32 52 /* 32 bit offset relative to TLS
+ block. */
+#define R_390_TLS_LDO64 53 /* 64 bit offset relative to TLS
+ block. */
+#define R_390_TLS_DTPMOD 54 /* ID of module containing symbol. */
+#define R_390_TLS_DTPOFF 55 /* Offset in TLS block. */
+#define R_390_TLS_TPOFF 56 /* Negated offset in static TLS
+ block. */
+#define R_390_20 57 /* Direct 20 bit. */
+#define R_390_GOT20 58 /* 20 bit GOT offset. */
+#define R_390_GOTPLT20 59 /* 20 bit offset to jump slot. */
+#define R_390_TLS_GOTIE20 60 /* 20 bit GOT offset for static TLS
+ block offset. */
+/* Keep this the last entry. */
+#define R_390_NUM 61
+
+
+/* CRIS relocations. */
+#define R_CRIS_NONE 0
+#define R_CRIS_8 1
+#define R_CRIS_16 2
+#define R_CRIS_32 3
+#define R_CRIS_8_PCREL 4
+#define R_CRIS_16_PCREL 5
+#define R_CRIS_32_PCREL 6
+#define R_CRIS_GNU_VTINHERIT 7
+#define R_CRIS_GNU_VTENTRY 8
+#define R_CRIS_COPY 9
+#define R_CRIS_GLOB_DAT 10
+#define R_CRIS_JUMP_SLOT 11
+#define R_CRIS_RELATIVE 12
+#define R_CRIS_16_GOT 13
+#define R_CRIS_32_GOT 14
+#define R_CRIS_16_GOTPLT 15
+#define R_CRIS_32_GOTPLT 16
+#define R_CRIS_32_GOTREL 17
+#define R_CRIS_32_PLT_GOTREL 18
+#define R_CRIS_32_PLT_PCREL 19
+
+#define R_CRIS_NUM 20
+
+
+/* AMD x86-64 relocations. */
+#define R_X86_64_NONE 0 /* No reloc */
+#define R_X86_64_64 1 /* Direct 64 bit */
+#define R_X86_64_PC32 2 /* PC relative 32 bit signed */
+#define R_X86_64_GOT32 3 /* 32 bit GOT entry */
+#define R_X86_64_PLT32 4 /* 32 bit PLT address */
+#define R_X86_64_COPY 5 /* Copy symbol at runtime */
+#define R_X86_64_GLOB_DAT 6 /* Create GOT entry */
+#define R_X86_64_JUMP_SLOT 7 /* Create PLT entry */
+#define R_X86_64_RELATIVE 8 /* Adjust by program base */
+#define R_X86_64_GOTPCREL 9 /* 32 bit signed PC relative
+ offset to GOT */
+#define R_X86_64_32 10 /* Direct 32 bit zero extended */
+#define R_X86_64_32S 11 /* Direct 32 bit sign extended */
+#define R_X86_64_16 12 /* Direct 16 bit zero extended */
+#define R_X86_64_PC16 13 /* 16 bit sign extended pc relative */
+#define R_X86_64_8 14 /* Direct 8 bit sign extended */
+#define R_X86_64_PC8 15 /* 8 bit sign extended pc relative */
+#define R_X86_64_DTPMOD64 16 /* ID of module containing symbol */
+#define R_X86_64_DTPOFF64 17 /* Offset in module's TLS block */
+#define R_X86_64_TPOFF64 18 /* Offset in initial TLS block */
+#define R_X86_64_TLSGD 19 /* 32 bit signed PC relative offset
+ to two GOT entries for GD symbol */
+#define R_X86_64_TLSLD 20 /* 32 bit signed PC relative offset
+ to two GOT entries for LD symbol */
+#define R_X86_64_DTPOFF32 21 /* Offset in TLS block */
+#define R_X86_64_GOTTPOFF 22 /* 32 bit signed PC relative offset
+ to GOT entry for IE symbol */
+#define R_X86_64_TPOFF32 23 /* Offset in initial TLS block */
+
+#define R_X86_64_NUM 24
+
+
+/* AM33 relocations. */
+#define R_MN10300_NONE 0 /* No reloc. */
+#define R_MN10300_32 1 /* Direct 32 bit. */
+#define R_MN10300_16 2 /* Direct 16 bit. */
+#define R_MN10300_8 3 /* Direct 8 bit. */
+#define R_MN10300_PCREL32 4 /* PC-relative 32-bit. */
+#define R_MN10300_PCREL16 5 /* PC-relative 16-bit signed. */
+#define R_MN10300_PCREL8 6 /* PC-relative 8-bit signed. */
+#define R_MN10300_GNU_VTINHERIT 7 /* Ancient C++ vtable garbage... */
+#define R_MN10300_GNU_VTENTRY 8 /* ... collection annotation. */
+#define R_MN10300_24 9 /* Direct 24 bit. */
+#define R_MN10300_GOTPC32 10 /* 32-bit PCrel offset to GOT. */
+#define R_MN10300_GOTPC16 11 /* 16-bit PCrel offset to GOT. */
+#define R_MN10300_GOTOFF32 12 /* 32-bit offset from GOT. */
+#define R_MN10300_GOTOFF24 13 /* 24-bit offset from GOT. */
+#define R_MN10300_GOTOFF16 14 /* 16-bit offset from GOT. */
+#define R_MN10300_PLT32 15 /* 32-bit PCrel to PLT entry. */
+#define R_MN10300_PLT16 16 /* 16-bit PCrel to PLT entry. */
+#define R_MN10300_GOT32 17 /* 32-bit offset to GOT entry. */
+#define R_MN10300_GOT24 18 /* 24-bit offset to GOT entry. */
+#define R_MN10300_GOT16 19 /* 16-bit offset to GOT entry. */
+#define R_MN10300_COPY 20 /* Copy symbol at runtime. */
+#define R_MN10300_GLOB_DAT 21 /* Create GOT entry. */
+#define R_MN10300_JMP_SLOT 22 /* Create PLT entry. */
+#define R_MN10300_RELATIVE 23 /* Adjust by program base. */
+
+#define R_MN10300_NUM 24
+
+
+/* M32R relocs. */
+#define R_M32R_NONE 0 /* No reloc. */
+#define R_M32R_16 1 /* Direct 16 bit. */
+#define R_M32R_32 2 /* Direct 32 bit. */
+#define R_M32R_24 3 /* Direct 24 bit. */
+#define R_M32R_10_PCREL 4 /* PC relative 10 bit shifted. */
+#define R_M32R_18_PCREL 5 /* PC relative 18 bit shifted. */
+#define R_M32R_26_PCREL 6 /* PC relative 26 bit shifted. */
+#define R_M32R_HI16_ULO 7 /* High 16 bit with unsigned low. */
+#define R_M32R_HI16_SLO 8 /* High 16 bit with signed low. */
+#define R_M32R_LO16 9 /* Low 16 bit. */
+#define R_M32R_SDA16 10 /* 16 bit offset in SDA. */
+#define R_M32R_GNU_VTINHERIT 11
+#define R_M32R_GNU_VTENTRY 12
+/* M32R relocs use SHT_RELA. */
+#define R_M32R_16_RELA 33 /* Direct 16 bit. */
+#define R_M32R_32_RELA 34 /* Direct 32 bit. */
+#define R_M32R_24_RELA 35 /* Direct 24 bit. */
+#define R_M32R_10_PCREL_RELA 36 /* PC relative 10 bit shifted. */
+#define R_M32R_18_PCREL_RELA 37 /* PC relative 18 bit shifted. */
+#define R_M32R_26_PCREL_RELA 38 /* PC relative 26 bit shifted. */
+#define R_M32R_HI16_ULO_RELA 39 /* High 16 bit with unsigned low */
+#define R_M32R_HI16_SLO_RELA 40 /* High 16 bit with signed low */
+#define R_M32R_LO16_RELA 41 /* Low 16 bit */
+#define R_M32R_SDA16_RELA 42 /* 16 bit offset in SDA */
+#define R_M32R_RELA_GNU_VTINHERIT 43
+#define R_M32R_RELA_GNU_VTENTRY 44
+#define R_M32R_REL32 45 /* PC relative 32 bit. */
+
+#define R_M32R_GOT24 48 /* 24 bit GOT entry */
+#define R_M32R_26_PLTREL 49 /* 26 bit PC relative to PLT shifted */
+#define R_M32R_COPY 50 /* Copy symbol at runtime */
+#define R_M32R_GLOB_DAT 51 /* Create GOT entry */
+#define R_M32R_JMP_SLOT 52 /* Create PLT entry */
+#define R_M32R_RELATIVE 53 /* Adjust by program base */
+#define R_M32R_GOTOFF 54 /* 24 bit offset to GOT */
+#define R_M32R_GOTPC24 55 /* 24 bit PC relative offset to GOT */
+#define R_M32R_GOT16_HI_ULO 56 /* High 16 bit GOT entry with unsigned
+ low */
+#define R_M32R_GOT16_HI_SLO 57 /* High 16 bit GOT entry with signed
+ low */
+#define R_M32R_GOT16_LO 58 /* Low 16 bit GOT entry */
+#define R_M32R_GOTPC_HI_ULO 59 /* High 16 bit PC relative offset to
+ GOT with unsigned low */
+#define R_M32R_GOTPC_HI_SLO 60 /* High 16 bit PC relative offset to
+ GOT with signed low */
+#define R_M32R_GOTPC_LO 61 /* Low 16 bit PC relative offset to
+ GOT */
+#define R_M32R_GOTOFF_HI_ULO 62 /* High 16 bit offset to GOT
+ with unsigned low */
+#define R_M32R_GOTOFF_HI_SLO 63 /* High 16 bit offset to GOT
+ with signed low */
+#define R_M32R_GOTOFF_LO 64 /* Low 16 bit offset to GOT */
+#define R_M32R_NUM 256 /* Keep this the last entry. */
+
+
+#endif /* elf.h */
--- /dev/null
+// InBuffer.h\r
+\r
+#ifndef __INBUFFER_H\r
+#define __INBUFFER_H\r
+\r
+#include "../IStream.h"\r
+#include "../../Common/MyCom.h"\r
+\r
+#ifndef _NO_EXCEPTIONS\r
+class CInBufferException\r
+{\r
+public:\r
+ HRESULT ErrorCode;\r
+ CInBufferException(HRESULT errorCode): ErrorCode(errorCode) {}\r
+};\r
+#endif\r
+\r
+class CInBuffer\r
+{\r
+ Byte *_buffer;\r
+ Byte *_bufferLimit;\r
+ Byte *_bufferBase;\r
+ CMyComPtr<ISequentialInStream> _stream;\r
+ UInt64 _processedSize;\r
+ UInt32 _bufferSize;\r
+ bool _wasFinished;\r
+\r
+ bool ReadBlock();\r
+ Byte ReadBlock2();\r
+\r
+public:\r
+ #ifdef _NO_EXCEPTIONS\r
+ HRESULT ErrorCode;\r
+ #endif\r
+\r
+ CInBuffer();\r
+ ~CInBuffer() { Free(); }\r
+\r
+ bool Create(UInt32 bufferSize);\r
+ void Free();\r
+ \r
+ void SetStream(ISequentialInStream *stream);\r
+ void Init();\r
+ void ReleaseStream() { _stream.Release(); }\r
+\r
+ bool ReadByte(Byte &b)\r
+ {\r
+ if(_buffer >= _bufferLimit)\r
+ if(!ReadBlock())\r
+ return false;\r
+ b = *_buffer++;\r
+ return true;\r
+ }\r
+ Byte ReadByte()\r
+ {\r
+ if(_buffer >= _bufferLimit)\r
+ return ReadBlock2();\r
+ return *_buffer++;\r
+ }\r
+ void ReadBytes(void *data, UInt32 size, UInt32 &processedSize)\r
+ {\r
+ for(processedSize = 0; processedSize < size; processedSize++)\r
+ if (!ReadByte(((Byte *)data)[processedSize]))\r
+ return;\r
+ }\r
+ bool ReadBytes(void *data, UInt32 size)\r
+ {\r
+ UInt32 processedSize;\r
+ ReadBytes(data, size, processedSize);\r
+ return (processedSize == size);\r
+ }\r
+ UInt64 GetProcessedSize() const { return _processedSize + (_buffer - _bufferBase); }\r
+ bool WasFinished() const { return _wasFinished; }\r
+};\r
+\r
+#endif\r
--- /dev/null
+// OutByte.cpp\r
+\r
+#include "StdAfx.h"\r
+\r
+#include "OutBuffer.h"\r
+\r
+#include "../../Common/Alloc.h"\r
+\r
+bool COutBuffer::Create(UInt32 bufferSize)\r
+{\r
+ const UInt32 kMinBlockSize = 1;\r
+ if (bufferSize < kMinBlockSize)\r
+ bufferSize = kMinBlockSize;\r
+ if (_buffer != 0 && _bufferSize == bufferSize)\r
+ return true;\r
+ Free();\r
+ _bufferSize = bufferSize;\r
+ _buffer = (Byte *)::MidAlloc(bufferSize);\r
+ return (_buffer != 0);\r
+}\r
+\r
+void COutBuffer::Free()\r
+{\r
+ ::MidFree(_buffer);\r
+ _buffer = 0;\r
+}\r
+\r
+void COutBuffer::SetStream(ISequentialOutStream *stream)\r
+{\r
+ _stream = stream;\r
+}\r
+\r
+void COutBuffer::Init()\r
+{\r
+ _streamPos = 0;\r
+ _limitPos = _bufferSize;\r
+ _pos = 0;\r
+ _processedSize = 0;\r
+ _overDict = false;\r
+ #ifdef _NO_EXCEPTIONS\r
+ ErrorCode = S_OK;\r
+ #endif\r
+}\r
+\r
+UInt64 COutBuffer::GetProcessedSize() const\r
+{ \r
+ UInt64 res = _processedSize + _pos - _streamPos;\r
+ if (_streamPos > _pos) \r
+ res += _bufferSize;\r
+ return res;\r
+}\r
+\r
+\r
+HRESULT COutBuffer::FlushPart()\r
+{\r
+ // _streamPos < _bufferSize\r
+ UInt32 size = (_streamPos >= _pos) ? (_bufferSize - _streamPos) : (_pos - _streamPos);\r
+ HRESULT result = S_OK;\r
+ #ifdef _NO_EXCEPTIONS\r
+ result = ErrorCode;\r
+ #endif\r
+ if (_buffer2 != 0)\r
+ {\r
+ memmove(_buffer2, _buffer + _streamPos, size);\r
+ _buffer2 += size;\r
+ }\r
+\r
+ if (_stream != 0\r
+ #ifdef _NO_EXCEPTIONS\r
+ && (ErrorCode == S_OK)\r
+ #endif\r
+ )\r
+ {\r
+ UInt32 processedSize = 0;\r
+ result = _stream->Write(_buffer + _streamPos, size, &processedSize);\r
+ size = processedSize;\r
+ }\r
+ _streamPos += size;\r
+ if (_streamPos == _bufferSize)\r
+ _streamPos = 0;\r
+ if (_pos == _bufferSize)\r
+ {\r
+ _overDict = true;\r
+ _pos = 0;\r
+ }\r
+ _limitPos = (_streamPos > _pos) ? _streamPos : _bufferSize;\r
+ _processedSize += size;\r
+ return result;\r
+}\r
+\r
+HRESULT COutBuffer::Flush()\r
+{\r
+ #ifdef _NO_EXCEPTIONS\r
+ if (ErrorCode != S_OK)\r
+ return ErrorCode;\r
+ #endif\r
+\r
+ while(_streamPos != _pos)\r
+ {\r
+ HRESULT result = FlushPart();\r
+ if (result != S_OK)\r
+ return result;\r
+ }\r
+ return S_OK;\r
+}\r
+\r
+void COutBuffer::FlushWithCheck()\r
+{\r
+ HRESULT result = FlushPart();\r
+ #ifdef _NO_EXCEPTIONS\r
+ ErrorCode = result;\r
+ #else\r
+ if (result != S_OK)\r
+ throw COutBufferException(result);\r
+ #endif\r
+}\r
--- /dev/null
+// OutBuffer.h\r
+\r
+#ifndef __OUTBUFFER_H\r
+#define __OUTBUFFER_H\r
+\r
+#include "../IStream.h"\r
+#include "../../Common/MyCom.h"\r
+\r
+#ifndef _NO_EXCEPTIONS\r
+struct COutBufferException\r
+{\r
+ HRESULT ErrorCode;\r
+ COutBufferException(HRESULT errorCode): ErrorCode(errorCode) {}\r
+};\r
+#endif\r
+\r
+class COutBuffer\r
+{\r
+protected:\r
+ Byte *_buffer;\r
+ UInt32 _pos;\r
+ UInt32 _limitPos;\r
+ UInt32 _streamPos;\r
+ UInt32 _bufferSize;\r
+ CMyComPtr<ISequentialOutStream> _stream;\r
+ UInt64 _processedSize;\r
+ Byte *_buffer2;\r
+ bool _overDict;\r
+\r
+ HRESULT FlushPart();\r
+ void FlushWithCheck();\r
+public:\r
+ #ifdef _NO_EXCEPTIONS\r
+ HRESULT ErrorCode;\r
+ #endif\r
+\r
+ COutBuffer(): _buffer(0), _pos(0), _stream(0), _buffer2(0) {}\r
+ ~COutBuffer() { Free(); }\r
+ \r
+ bool Create(UInt32 bufferSize);\r
+ void Free();\r
+\r
+ void SetMemStream(Byte *buffer) { _buffer2 = buffer; }\r
+ void SetStream(ISequentialOutStream *stream);\r
+ void Init();\r
+ HRESULT Flush();\r
+ void ReleaseStream() { _stream.Release(); }\r
+\r
+ void WriteByte(Byte b)\r
+ {\r
+ _buffer[_pos++] = b;\r
+ if(_pos == _limitPos)\r
+ FlushWithCheck();\r
+ }\r
+ void WriteBytes(const void *data, size_t size)\r
+ {\r
+ for (size_t i = 0; i < size; i++)\r
+ WriteByte(((const Byte *)data)[i]);\r
+ }\r
+\r
+ UInt64 GetProcessedSize() const;\r
+};\r
+\r
+#endif\r
--- /dev/null
+// StdAfx.h\r
+\r
+#ifndef __STDAFX_H\r
+#define __STDAFX_H\r
+\r
+#include "../../Common/MyWindows.h"\r
+#include "../../Common/NewHandler.h"\r
+\r
+#endif \r
--- /dev/null
+// StreamUtils.cpp\r
+\r
+#include "StdAfx.h"\r
+\r
+#include "../../Common/MyCom.h"\r
+#include "StreamUtils.h"\r
+\r
+HRESULT ReadStream(ISequentialInStream *stream, void *data, UInt32 size, UInt32 *processedSize)\r
+{\r
+ if (processedSize != 0)\r
+ *processedSize = 0;\r
+ while(size != 0)\r
+ {\r
+ UInt32 processedSizeLoc; \r
+ HRESULT res = stream->Read(data, size, &processedSizeLoc);\r
+ if (processedSize != 0)\r
+ *processedSize += processedSizeLoc;\r
+ data = (Byte *)((Byte *)data + processedSizeLoc);\r
+ size -= processedSizeLoc;\r
+ RINOK(res);\r
+ if (processedSizeLoc == 0)\r
+ return S_OK;\r
+ }\r
+ return S_OK;\r
+}\r
+\r
+HRESULT WriteStream(ISequentialOutStream *stream, const void *data, UInt32 size, UInt32 *processedSize)\r
+{\r
+ if (processedSize != 0)\r
+ *processedSize = 0;\r
+ while(size != 0)\r
+ {\r
+ UInt32 processedSizeLoc; \r
+ HRESULT res = stream->Write(data, size, &processedSizeLoc);\r
+ if (processedSize != 0)\r
+ *processedSize += processedSizeLoc;\r
+ data = (const void *)((const Byte *)data + processedSizeLoc);\r
+ size -= processedSizeLoc;\r
+ RINOK(res);\r
+ if (processedSizeLoc == 0)\r
+ break;\r
+ }\r
+ return S_OK;\r
+}\r
--- /dev/null
+// StreamUtils.h\r
+\r
+#ifndef __STREAMUTILS_H\r
+#define __STREAMUTILS_H\r
+\r
+#include "../IStream.h"\r
+\r
+HRESULT ReadStream(ISequentialInStream *stream, void *data, UInt32 size, UInt32 *processedSize);\r
+HRESULT WriteStream(ISequentialOutStream *stream, const void *data, UInt32 size, UInt32 *processedSize);\r
+\r
+#endif\r
--- /dev/null
+// BinTree.h\r
+\r
+#include "../LZInWindow.h"\r
+#include "../IMatchFinder.h"\r
+ \r
+namespace BT_NAMESPACE {\r
+\r
+typedef UInt32 CIndex;\r
+const UInt32 kMaxValForNormalize = (UInt32(1) << 31) - 1;\r
+\r
+class CMatchFinder: \r
+ public IMatchFinder,\r
+ public CLZInWindow,\r
+ public CMyUnknownImp,\r
+ public IMatchFinderSetNumPasses\r
+{\r
+ UInt32 _cyclicBufferPos;\r
+ UInt32 _cyclicBufferSize; // it must be historySize + 1\r
+ UInt32 _matchMaxLen;\r
+ CIndex *_hash;\r
+ CIndex *_son;\r
+ UInt32 _hashMask;\r
+ UInt32 _cutValue;\r
+ UInt32 _hashSizeSum;\r
+\r
+ void Normalize();\r
+ void FreeThisClassMemory();\r
+ void FreeMemory();\r
+\r
+ MY_UNKNOWN_IMP\r
+\r
+ STDMETHOD(SetStream)(ISequentialInStream *inStream);\r
+ STDMETHOD_(void, ReleaseStream)();\r
+ STDMETHOD(Init)();\r
+ HRESULT MovePos();\r
+ STDMETHOD_(Byte, GetIndexByte)(Int32 index);\r
+ STDMETHOD_(UInt32, GetMatchLen)(Int32 index, UInt32 back, UInt32 limit);\r
+ STDMETHOD_(UInt32, GetNumAvailableBytes)();\r
+ STDMETHOD_(const Byte *, GetPointerToCurrentPos)();\r
+ STDMETHOD_(Int32, NeedChangeBufferPos)(UInt32 numCheckBytes);\r
+ STDMETHOD_(void, ChangeBufferPos)();\r
+\r
+ STDMETHOD(Create)(UInt32 historySize, UInt32 keepAddBufferBefore, \r
+ UInt32 matchMaxLen, UInt32 keepAddBufferAfter);\r
+ STDMETHOD(GetMatches)(UInt32 *distances);\r
+ STDMETHOD(Skip)(UInt32 num);\r
+\r
+public:\r
+ CMatchFinder();\r
+ virtual ~CMatchFinder();\r
+ virtual void SetNumPasses(UInt32 numPasses) { _cutValue = numPasses; }\r
+};\r
+\r
+}\r
--- /dev/null
+// BinTree2.h\r
+\r
+#ifndef __BINTREE2_H\r
+#define __BINTREE2_H\r
+\r
+#define BT_NAMESPACE NBT2\r
+\r
+#include "BinTreeMain.h"\r
+\r
+#undef BT_NAMESPACE\r
+\r
+#endif\r
--- /dev/null
+// BinTree3.h\r
+\r
+#ifndef __BINTREE3_H\r
+#define __BINTREE3_H\r
+\r
+#define BT_NAMESPACE NBT3\r
+\r
+#define HASH_ARRAY_2\r
+\r
+#include "BinTreeMain.h"\r
+\r
+#undef HASH_ARRAY_2\r
+\r
+#undef BT_NAMESPACE\r
+\r
+#endif\r
--- /dev/null
+// BinTree4.h\r
+\r
+#ifndef __BINTREE4_H\r
+#define __BINTREE4_H\r
+\r
+#define BT_NAMESPACE NBT4\r
+\r
+#define HASH_ARRAY_2\r
+#define HASH_ARRAY_3\r
+\r
+#include "BinTreeMain.h"\r
+\r
+#undef HASH_ARRAY_2\r
+#undef HASH_ARRAY_3\r
+\r
+#undef BT_NAMESPACE\r
+\r
+#endif\r
--- /dev/null
+// BinTreeMain.h\r
+\r
+#include "../../../../Common/Defs.h"\r
+#include "../../../../Common/CRC.h"\r
+#include "../../../../Common/Alloc.h"\r
+\r
+#include "BinTree.h"\r
+\r
+// #include <xmmintrin.h>\r
+// It's for prefetch\r
+// But prefetch doesn't give big gain in K8.\r
+\r
+namespace BT_NAMESPACE {\r
+\r
+#ifdef HASH_ARRAY_2\r
+ static const UInt32 kHash2Size = 1 << 10;\r
+ #define kNumHashDirectBytes 0\r
+ #ifdef HASH_ARRAY_3\r
+ static const UInt32 kNumHashBytes = 4;\r
+ static const UInt32 kHash3Size = 1 << 16;\r
+ #else\r
+ static const UInt32 kNumHashBytes = 3;\r
+ #endif\r
+ static const UInt32 kHashSize = 0;\r
+ static const UInt32 kMinMatchCheck = kNumHashBytes;\r
+ static const UInt32 kStartMaxLen = 1;\r
+#else\r
+ #ifdef HASH_ZIP \r
+ #define kNumHashDirectBytes 0\r
+ static const UInt32 kNumHashBytes = 3;\r
+ static const UInt32 kHashSize = 1 << 16;\r
+ static const UInt32 kMinMatchCheck = kNumHashBytes;\r
+ static const UInt32 kStartMaxLen = 1;\r
+ #else\r
+ #define kNumHashDirectBytes 2\r
+ static const UInt32 kNumHashBytes = 2;\r
+ static const UInt32 kHashSize = 1 << (8 * kNumHashBytes);\r
+ static const UInt32 kMinMatchCheck = kNumHashBytes + 1;\r
+ static const UInt32 kStartMaxLen = 1;\r
+ #endif\r
+#endif\r
+\r
+#ifdef HASH_ARRAY_2\r
+#ifdef HASH_ARRAY_3\r
+static const UInt32 kHash3Offset = kHash2Size;\r
+#endif\r
+#endif\r
+\r
+static const UInt32 kFixHashSize = 0\r
+ #ifdef HASH_ARRAY_2\r
+ + kHash2Size\r
+ #ifdef HASH_ARRAY_3\r
+ + kHash3Size\r
+ #endif\r
+ #endif\r
+ ;\r
+\r
+CMatchFinder::CMatchFinder():\r
+ _hash(0)\r
+{\r
+}\r
+\r
+void CMatchFinder::FreeThisClassMemory()\r
+{\r
+ BigFree(_hash);\r
+ _hash = 0;\r
+}\r
+\r
+void CMatchFinder::FreeMemory()\r
+{\r
+ FreeThisClassMemory();\r
+ CLZInWindow::Free();\r
+}\r
+\r
+CMatchFinder::~CMatchFinder()\r
+{ \r
+ FreeMemory();\r
+}\r
+\r
+STDMETHODIMP CMatchFinder::Create(UInt32 historySize, UInt32 keepAddBufferBefore, \r
+ UInt32 matchMaxLen, UInt32 keepAddBufferAfter)\r
+{\r
+ if (historySize > kMaxValForNormalize - 256)\r
+ {\r
+ FreeMemory();\r
+ return E_INVALIDARG;\r
+ }\r
+ _cutValue = \r
+ #ifdef _HASH_CHAIN\r
+ 8 + (matchMaxLen >> 2);\r
+ #else\r
+ 16 + (matchMaxLen >> 1);\r
+ #endif\r
+ UInt32 sizeReserv = (historySize + keepAddBufferBefore + \r
+ matchMaxLen + keepAddBufferAfter) / 2 + 256;\r
+ if (CLZInWindow::Create(historySize + keepAddBufferBefore, \r
+ matchMaxLen + keepAddBufferAfter, sizeReserv))\r
+ {\r
+ _matchMaxLen = matchMaxLen;\r
+ UInt32 newCyclicBufferSize = historySize + 1;\r
+ if (_hash != 0 && newCyclicBufferSize == _cyclicBufferSize)\r
+ return S_OK;\r
+ FreeThisClassMemory();\r
+ _cyclicBufferSize = newCyclicBufferSize; // don't change it\r
+\r
+ UInt32 hs = kHashSize;\r
+\r
+ #ifdef HASH_ARRAY_2\r
+ hs = historySize - 1;\r
+ hs |= (hs >> 1);\r
+ hs |= (hs >> 2);\r
+ hs |= (hs >> 4);\r
+ hs |= (hs >> 8);\r
+ hs >>= 1;\r
+ hs |= 0xFFFF;\r
+ if (hs > (1 << 24))\r
+ {\r
+ #ifdef HASH_ARRAY_3\r
+ hs >>= 1;\r
+ #else\r
+ hs = (1 << 24) - 1;\r
+ #endif\r
+ }\r
+ _hashMask = hs;\r
+ hs++;\r
+ #endif\r
+ _hashSizeSum = hs + kFixHashSize;\r
+ UInt32 numItems = _hashSizeSum + _cyclicBufferSize\r
+ #ifndef _HASH_CHAIN\r
+ * 2\r
+ #endif\r
+ ;\r
+ size_t sizeInBytes = (size_t)numItems * sizeof(CIndex);\r
+ if (sizeInBytes / sizeof(CIndex) != numItems)\r
+ return E_OUTOFMEMORY;\r
+ _hash = (CIndex *)BigAlloc(sizeInBytes);\r
+ _son = _hash + _hashSizeSum;\r
+ if (_hash != 0)\r
+ return S_OK;\r
+ }\r
+ FreeMemory();\r
+ return E_OUTOFMEMORY;\r
+}\r
+\r
+static const UInt32 kEmptyHashValue = 0;\r
+\r
+STDMETHODIMP CMatchFinder::SetStream(ISequentialInStream *stream)\r
+{\r
+ CLZInWindow::SetStream(stream);\r
+ return S_OK;\r
+}\r
+\r
+STDMETHODIMP CMatchFinder::Init()\r
+{\r
+ RINOK(CLZInWindow::Init());\r
+ for(UInt32 i = 0; i < _hashSizeSum; i++)\r
+ _hash[i] = kEmptyHashValue;\r
+ _cyclicBufferPos = 0;\r
+ ReduceOffsets(-1);\r
+ return S_OK;\r
+}\r
+\r
+STDMETHODIMP_(void) CMatchFinder::ReleaseStream()\r
+{ \r
+ // ReleaseStream(); \r
+}\r
+\r
+#ifdef HASH_ARRAY_2\r
+#ifdef HASH_ARRAY_3\r
+\r
+#define HASH_CALC { \\r
+ UInt32 temp = CCRC::Table[cur[0]] ^ cur[1]; \\r
+ hash2Value = temp & (kHash2Size - 1); \\r
+ hash3Value = (temp ^ (UInt32(cur[2]) << 8)) & (kHash3Size - 1); \\r
+ hashValue = (temp ^ (UInt32(cur[2]) << 8) ^ (CCRC::Table[cur[3]] << 5)) & _hashMask; }\r
+ \r
+#else // no HASH_ARRAY_3\r
+#define HASH_CALC { \\r
+ UInt32 temp = CCRC::Table[cur[0]] ^ cur[1]; \\r
+ hash2Value = temp & (kHash2Size - 1); \\r
+ hashValue = (temp ^ (UInt32(cur[2]) << 8)) & _hashMask; }\r
+#endif // HASH_ARRAY_3\r
+#else // no HASH_ARRAY_2\r
+#ifdef HASH_ZIP \r
+inline UInt32 Hash(const Byte *pointer)\r
+{\r
+ return ((UInt32(pointer[0]) << 8) ^ CCRC::Table[pointer[1]] ^ pointer[2]) & (kHashSize - 1);\r
+}\r
+#else // no HASH_ZIP \r
+inline UInt32 Hash(const Byte *pointer)\r
+{\r
+ return pointer[0] ^ (UInt32(pointer[1]) << 8);\r
+}\r
+#endif // HASH_ZIP\r
+#endif // HASH_ARRAY_2\r
+\r
+STDMETHODIMP CMatchFinder::GetMatches(UInt32 *distances)\r
+{\r
+ UInt32 lenLimit;\r
+ if (_pos + _matchMaxLen <= _streamPos)\r
+ lenLimit = _matchMaxLen;\r
+ else\r
+ {\r
+ lenLimit = _streamPos - _pos;\r
+ if(lenLimit < kMinMatchCheck)\r
+ {\r
+ distances[0] = 0;\r
+ return MovePos(); \r
+ }\r
+ }\r
+\r
+ int offset = 1;\r
+\r
+ UInt32 matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;\r
+ const Byte *cur = _buffer + _pos;\r
+\r
+ UInt32 maxLen = kStartMaxLen; // to avoid items for len < hashSize;\r
+\r
+ #ifdef HASH_ARRAY_2\r
+ UInt32 hash2Value;\r
+ #ifdef HASH_ARRAY_3\r
+ UInt32 hash3Value;\r
+ #endif\r
+ UInt32 hashValue;\r
+ HASH_CALC;\r
+ #else\r
+ UInt32 hashValue = Hash(cur);\r
+ #endif\r
+\r
+ UInt32 curMatch = _hash[kFixHashSize + hashValue];\r
+ #ifdef HASH_ARRAY_2\r
+ UInt32 curMatch2 = _hash[hash2Value];\r
+ #ifdef HASH_ARRAY_3\r
+ UInt32 curMatch3 = _hash[kHash3Offset + hash3Value];\r
+ #endif\r
+ _hash[hash2Value] = _pos;\r
+ if(curMatch2 > matchMinPos)\r
+ if (_buffer[curMatch2] == cur[0])\r
+ {\r
+ distances[offset++] = maxLen = 2;\r
+ distances[offset++] = _pos - curMatch2 - 1;\r
+ }\r
+\r
+ #ifdef HASH_ARRAY_3\r
+ _hash[kHash3Offset + hash3Value] = _pos;\r
+ if(curMatch3 > matchMinPos)\r
+ if (_buffer[curMatch3] == cur[0])\r
+ {\r
+ if (curMatch3 == curMatch2)\r
+ offset -= 2;\r
+ distances[offset++] = maxLen = 3;\r
+ distances[offset++] = _pos - curMatch3 - 1;\r
+ curMatch2 = curMatch3;\r
+ }\r
+ #endif\r
+ if (offset != 1 && curMatch2 == curMatch)\r
+ {\r
+ offset -= 2;\r
+ maxLen = kStartMaxLen;\r
+ }\r
+ #endif\r
+\r
+ _hash[kFixHashSize + hashValue] = _pos;\r
+\r
+ CIndex *son = _son;\r
+\r
+ #ifdef _HASH_CHAIN\r
+ son[_cyclicBufferPos] = curMatch;\r
+ #else\r
+ CIndex *ptr0 = son + (_cyclicBufferPos << 1) + 1;\r
+ CIndex *ptr1 = son + (_cyclicBufferPos << 1);\r
+\r
+ UInt32 len0, len1;\r
+ len0 = len1 = kNumHashDirectBytes;\r
+ #endif\r
+\r
+ #if kNumHashDirectBytes != 0\r
+ if(curMatch > matchMinPos)\r
+ {\r
+ if (_buffer[curMatch + kNumHashDirectBytes] != cur[kNumHashDirectBytes])\r
+ {\r
+ distances[offset++] = maxLen = kNumHashDirectBytes;\r
+ distances[offset++] = _pos - curMatch - 1;\r
+ }\r
+ }\r
+ #endif\r
+ UInt32 count = _cutValue;\r
+ while(true)\r
+ {\r
+ if(curMatch <= matchMinPos || count-- == 0)\r
+ {\r
+ #ifndef _HASH_CHAIN\r
+ *ptr0 = *ptr1 = kEmptyHashValue;\r
+ #endif\r
+ break;\r
+ }\r
+ UInt32 delta = _pos - curMatch;\r
+ UInt32 cyclicPos = (delta <= _cyclicBufferPos) ?\r
+ (_cyclicBufferPos - delta):\r
+ (_cyclicBufferPos - delta + _cyclicBufferSize);\r
+ CIndex *pair = son + \r
+ #ifdef _HASH_CHAIN\r
+ cyclicPos;\r
+ #else\r
+ (cyclicPos << 1);\r
+ #endif\r
+ \r
+ // _mm_prefetch((const char *)pair, _MM_HINT_T0);\r
+ \r
+ const Byte *pb = _buffer + curMatch;\r
+ UInt32 len = \r
+ #ifdef _HASH_CHAIN\r
+ kNumHashDirectBytes;\r
+ if (pb[maxLen] == cur[maxLen])\r
+ #else\r
+ MyMin(len0, len1);\r
+ #endif\r
+ if (pb[len] == cur[len])\r
+ {\r
+ while(++len != lenLimit)\r
+ if (pb[len] != cur[len])\r
+ break;\r
+ if (maxLen < len)\r
+ {\r
+ distances[offset++] = maxLen = len;\r
+ distances[offset++] = delta - 1;\r
+ if (len == lenLimit)\r
+ {\r
+ #ifndef _HASH_CHAIN\r
+ *ptr1 = pair[0];\r
+ *ptr0 = pair[1];\r
+ #endif\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ #ifdef _HASH_CHAIN\r
+ curMatch = *pair;\r
+ #else\r
+ if (pb[len] < cur[len])\r
+ {\r
+ *ptr1 = curMatch;\r
+ ptr1 = pair + 1;\r
+ curMatch = *ptr1;\r
+ len1 = len;\r
+ }\r
+ else\r
+ {\r
+ *ptr0 = curMatch;\r
+ ptr0 = pair;\r
+ curMatch = *ptr0;\r
+ len0 = len;\r
+ }\r
+ #endif\r
+ }\r
+ distances[0] = offset - 1;\r
+ if (++_cyclicBufferPos == _cyclicBufferSize)\r
+ _cyclicBufferPos = 0;\r
+ RINOK(CLZInWindow::MovePos());\r
+ if (_pos == kMaxValForNormalize)\r
+ Normalize();\r
+ return S_OK;\r
+}\r
+\r
+STDMETHODIMP CMatchFinder::Skip(UInt32 num)\r
+{\r
+ do\r
+ {\r
+ #ifdef _HASH_CHAIN\r
+ if (_streamPos - _pos < kNumHashBytes)\r
+ {\r
+ RINOK(MovePos()); \r
+ continue;\r
+ }\r
+ #else\r
+ UInt32 lenLimit;\r
+ if (_pos + _matchMaxLen <= _streamPos)\r
+ lenLimit = _matchMaxLen;\r
+ else\r
+ {\r
+ lenLimit = _streamPos - _pos;\r
+ if(lenLimit < kMinMatchCheck)\r
+ {\r
+ RINOK(MovePos());\r
+ continue;\r
+ }\r
+ }\r
+ UInt32 matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;\r
+ #endif\r
+ const Byte *cur = _buffer + _pos;\r
+\r
+ #ifdef HASH_ARRAY_2\r
+ UInt32 hash2Value;\r
+ #ifdef HASH_ARRAY_3\r
+ UInt32 hash3Value;\r
+ UInt32 hashValue;\r
+ HASH_CALC;\r
+ _hash[kHash3Offset + hash3Value] = _pos;\r
+ #else\r
+ UInt32 hashValue;\r
+ HASH_CALC;\r
+ #endif\r
+ _hash[hash2Value] = _pos;\r
+ #else\r
+ UInt32 hashValue = Hash(cur);\r
+ #endif\r
+\r
+ UInt32 curMatch = _hash[kFixHashSize + hashValue];\r
+ _hash[kFixHashSize + hashValue] = _pos;\r
+\r
+ #ifdef _HASH_CHAIN\r
+ _son[_cyclicBufferPos] = curMatch;\r
+ #else\r
+ CIndex *son = _son;\r
+ CIndex *ptr0 = son + (_cyclicBufferPos << 1) + 1;\r
+ CIndex *ptr1 = son + (_cyclicBufferPos << 1);\r
+\r
+ UInt32 len0, len1;\r
+ len0 = len1 = kNumHashDirectBytes;\r
+ UInt32 count = _cutValue;\r
+ while(true)\r
+ {\r
+ if(curMatch <= matchMinPos || count-- == 0)\r
+ {\r
+ *ptr0 = *ptr1 = kEmptyHashValue;\r
+ break;\r
+ }\r
+ \r
+ UInt32 delta = _pos - curMatch;\r
+ UInt32 cyclicPos = (delta <= _cyclicBufferPos) ?\r
+ (_cyclicBufferPos - delta):\r
+ (_cyclicBufferPos - delta + _cyclicBufferSize);\r
+ CIndex *pair = son + (cyclicPos << 1);\r
+ \r
+ // _mm_prefetch((const char *)pair, _MM_HINT_T0);\r
+ \r
+ const Byte *pb = _buffer + curMatch;\r
+ UInt32 len = MyMin(len0, len1);\r
+ \r
+ if (pb[len] == cur[len])\r
+ {\r
+ while(++len != lenLimit)\r
+ if (pb[len] != cur[len])\r
+ break;\r
+ if (len == lenLimit)\r
+ {\r
+ *ptr1 = pair[0];\r
+ *ptr0 = pair[1];\r
+ break;\r
+ }\r
+ }\r
+ if (pb[len] < cur[len])\r
+ {\r
+ *ptr1 = curMatch;\r
+ ptr1 = pair + 1;\r
+ curMatch = *ptr1;\r
+ len1 = len;\r
+ }\r
+ else\r
+ {\r
+ *ptr0 = curMatch;\r
+ ptr0 = pair;\r
+ curMatch = *ptr0;\r
+ len0 = len;\r
+ }\r
+ }\r
+ #endif\r
+ if (++_cyclicBufferPos == _cyclicBufferSize)\r
+ _cyclicBufferPos = 0;\r
+ RINOK(CLZInWindow::MovePos());\r
+ if (_pos == kMaxValForNormalize)\r
+ Normalize();\r
+ }\r
+ while(--num != 0);\r
+ return S_OK;\r
+}\r
+\r
+void CMatchFinder::Normalize()\r
+{\r
+ UInt32 subValue = _pos - _cyclicBufferSize;\r
+ CIndex *items = _hash;\r
+ UInt32 numItems = (_hashSizeSum + _cyclicBufferSize \r
+ #ifndef _HASH_CHAIN\r
+ * 2\r
+ #endif\r
+ );\r
+ for (UInt32 i = 0; i < numItems; i++)\r
+ {\r
+ UInt32 value = items[i];\r
+ if (value <= subValue)\r
+ value = kEmptyHashValue;\r
+ else\r
+ value -= subValue;\r
+ items[i] = value;\r
+ }\r
+ ReduceOffsets(subValue);\r
+}\r
+\r
+HRESULT CMatchFinder::MovePos()\r
+{\r
+ if (++_cyclicBufferPos == _cyclicBufferSize)\r
+ _cyclicBufferPos = 0;\r
+ RINOK(CLZInWindow::MovePos());\r
+ if (_pos == kMaxValForNormalize)\r
+ Normalize();\r
+ return S_OK;\r
+}\r
+\r
+STDMETHODIMP_(Byte) CMatchFinder::GetIndexByte(Int32 index)\r
+ { return CLZInWindow::GetIndexByte(index); }\r
+\r
+STDMETHODIMP_(UInt32) CMatchFinder::GetMatchLen(Int32 index, \r
+ UInt32 back, UInt32 limit)\r
+ { return CLZInWindow::GetMatchLen(index, back, limit); }\r
+\r
+STDMETHODIMP_(UInt32) CMatchFinder::GetNumAvailableBytes()\r
+ { return CLZInWindow::GetNumAvailableBytes(); }\r
+\r
+STDMETHODIMP_(const Byte *) CMatchFinder::GetPointerToCurrentPos()\r
+ { return CLZInWindow::GetPointerToCurrentPos(); }\r
+\r
+STDMETHODIMP_(Int32) CMatchFinder::NeedChangeBufferPos(UInt32 numCheckBytes)\r
+ { return CLZInWindow::NeedMove(numCheckBytes) ? 1: 0; }\r
+\r
+STDMETHODIMP_(void) CMatchFinder::ChangeBufferPos()\r
+ { CLZInWindow::MoveBlock();}\r
+\r
+#undef HASH_CALC\r
+#undef kNumHashDirectBytes\r
+ \r
+}\r
--- /dev/null
+// HC4.h\r
+\r
+#ifndef __HC4_H\r
+#define __HC4_H\r
+\r
+#define BT_NAMESPACE NHC4\r
+\r
+#define HASH_ARRAY_2\r
+#define HASH_ARRAY_3\r
+\r
+#include "HCMain.h"\r
+\r
+#undef HASH_ARRAY_2\r
+#undef HASH_ARRAY_3\r
+\r
+#undef BT_NAMESPACE\r
+\r
+#endif\r
+\r
--- /dev/null
+// HCMain.h\r
+\r
+#define _HASH_CHAIN\r
+#include "../BinTree/BinTreeMain.h"\r
+#undef _HASH_CHAIN\r
+\r
--- /dev/null
+// MatchFinders/IMatchFinder.h\r
+\r
+#ifndef __IMATCHFINDER_H\r
+#define __IMATCHFINDER_H\r
+\r
+struct IInWindowStream: public IUnknown\r
+{\r
+ STDMETHOD(SetStream)(ISequentialInStream *inStream) PURE;\r
+ STDMETHOD_(void, ReleaseStream)() PURE;\r
+ STDMETHOD(Init)() PURE;\r
+ STDMETHOD_(Byte, GetIndexByte)(Int32 index) PURE;\r
+ STDMETHOD_(UInt32, GetMatchLen)(Int32 index, UInt32 distance, UInt32 limit) PURE;\r
+ STDMETHOD_(UInt32, GetNumAvailableBytes)() PURE;\r
+ STDMETHOD_(const Byte *, GetPointerToCurrentPos)() PURE;\r
+ STDMETHOD_(Int32, NeedChangeBufferPos)(UInt32 numCheckBytes) PURE;\r
+ STDMETHOD_(void, ChangeBufferPos)() PURE;\r
+};\r
+ \r
+struct IMatchFinder: public IInWindowStream\r
+{\r
+ STDMETHOD(Create)(UInt32 historySize, UInt32 keepAddBufferBefore, \r
+ UInt32 matchMaxLen, UInt32 keepAddBufferAfter) PURE;\r
+ STDMETHOD(GetMatches)(UInt32 *distances) PURE;\r
+ STDMETHOD(Skip)(UInt32 num) PURE;\r
+};\r
+\r
+struct IMatchFinderSetNumPasses\r
+{\r
+ //virtual ~IMatchFinderSetNumPasses(){}\r
+ virtual void SetNumPasses(UInt32 numPasses) PURE;\r
+};\r
+\r
+#endif\r
--- /dev/null
+// LZInWindow.cpp\r
+\r
+#include "StdAfx.h"\r
+\r
+#include "LZInWindow.h"\r
+#include "../../../Common/MyCom.h"\r
+#include "../../../Common/Alloc.h"\r
+\r
+void CLZInWindow::Free()\r
+{\r
+ ::BigFree(_bufferBase);\r
+ _bufferBase = 0;\r
+}\r
+\r
+bool CLZInWindow::Create(UInt32 keepSizeBefore, UInt32 keepSizeAfter, UInt32 keepSizeReserv)\r
+{\r
+ _keepSizeBefore = keepSizeBefore;\r
+ _keepSizeAfter = keepSizeAfter;\r
+ UInt32 blockSize = keepSizeBefore + keepSizeAfter + keepSizeReserv;\r
+ if (_bufferBase == 0 || _blockSize != blockSize)\r
+ {\r
+ Free();\r
+ _blockSize = blockSize;\r
+ if (_blockSize != 0)\r
+ _bufferBase = (Byte *)::BigAlloc(_blockSize);\r
+ }\r
+ _pointerToLastSafePosition = _bufferBase + _blockSize - keepSizeAfter;\r
+ if (_blockSize == 0)\r
+ return true;\r
+ return (_bufferBase != 0);\r
+}\r
+\r
+void CLZInWindow::SetStream(ISequentialInStream *stream)\r
+{\r
+ _stream = stream;\r
+}\r
+\r
+HRESULT CLZInWindow::Init()\r
+{\r
+ _buffer = _bufferBase;\r
+ _pos = 0;\r
+ _streamPos = 0;\r
+ _streamEndWasReached = false;\r
+ return ReadBlock();\r
+}\r
+\r
+/*\r
+void CLZInWindow::ReleaseStream()\r
+{\r
+ _stream.Release();\r
+}\r
+*/\r
+\r
+///////////////////////////////////////////\r
+// ReadBlock\r
+\r
+// In State:\r
+// (_buffer + _streamPos) <= (_bufferBase + _blockSize)\r
+// Out State:\r
+// _posLimit <= _blockSize - _keepSizeAfter;\r
+// if(_streamEndWasReached == false):\r
+// _streamPos >= _pos + _keepSizeAfter\r
+// _posLimit = _streamPos - _keepSizeAfter;\r
+// else\r
+// \r
+ \r
+HRESULT CLZInWindow::ReadBlock()\r
+{\r
+ if(_streamEndWasReached)\r
+ return S_OK;\r
+ while(true)\r
+ {\r
+ UInt32 size = (UInt32)(_bufferBase - _buffer) + _blockSize - _streamPos;\r
+ if(size == 0)\r
+ return S_OK;\r
+ UInt32 numReadBytes;\r
+ RINOK(_stream->Read(_buffer + _streamPos, size, &numReadBytes));\r
+ if(numReadBytes == 0)\r
+ {\r
+ _posLimit = _streamPos;\r
+ const Byte *pointerToPostion = _buffer + _posLimit;\r
+ if(pointerToPostion > _pointerToLastSafePosition)\r
+ _posLimit = (UInt32)(_pointerToLastSafePosition - _buffer);\r
+ _streamEndWasReached = true;\r
+ return S_OK;\r
+ }\r
+ _streamPos += numReadBytes;\r
+ if(_streamPos >= _pos + _keepSizeAfter)\r
+ {\r
+ _posLimit = _streamPos - _keepSizeAfter;\r
+ return S_OK;\r
+ }\r
+ }\r
+}\r
+\r
+void CLZInWindow::MoveBlock()\r
+{\r
+ UInt32 offset = (UInt32)(_buffer - _bufferBase) + _pos - _keepSizeBefore;\r
+ // we need one additional byte, since MovePos moves on 1 byte.\r
+ if (offset > 0)\r
+ offset--; \r
+ UInt32 numBytes = (UInt32)(_buffer - _bufferBase) + _streamPos - offset;\r
+ memmove(_bufferBase, _bufferBase + offset, numBytes);\r
+ _buffer -= offset;\r
+}\r
--- /dev/null
+// LZInWindow.h\r
+\r
+#ifndef __LZ_IN_WINDOW_H\r
+#define __LZ_IN_WINDOW_H\r
+\r
+#include "../../IStream.h"\r
+\r
+class CLZInWindow\r
+{\r
+ Byte *_bufferBase; // pointer to buffer with data\r
+ ISequentialInStream *_stream;\r
+ UInt32 _posLimit; // offset (from _buffer) when new block reading must be done\r
+ bool _streamEndWasReached; // if (true) then _streamPos shows real end of stream\r
+ const Byte *_pointerToLastSafePosition;\r
+protected:\r
+ Byte *_buffer; // Pointer to virtual Buffer begin\r
+ UInt32 _blockSize; // Size of Allocated memory block\r
+ UInt32 _pos; // offset (from _buffer) of curent byte\r
+ UInt32 _keepSizeBefore; // how many BYTEs must be kept in buffer before _pos\r
+ UInt32 _keepSizeAfter; // how many BYTEs must be kept buffer after _pos\r
+ UInt32 _streamPos; // offset (from _buffer) of first not read byte from Stream\r
+\r
+ void MoveBlock();\r
+ HRESULT ReadBlock();\r
+ void Free();\r
+public:\r
+ CLZInWindow(): _bufferBase(0) {}\r
+ virtual ~CLZInWindow() { Free(); }\r
+\r
+ // keepSizeBefore + keepSizeAfter + keepSizeReserv < 4G)\r
+ bool Create(UInt32 keepSizeBefore, UInt32 keepSizeAfter, UInt32 keepSizeReserv = (1<<17));\r
+\r
+ void SetStream(ISequentialInStream *stream);\r
+ HRESULT Init();\r
+ // void ReleaseStream();\r
+\r
+ Byte *GetBuffer() const { return _buffer; }\r
+\r
+ const Byte *GetPointerToCurrentPos() const { return _buffer + _pos; }\r
+\r
+ HRESULT MovePos()\r
+ {\r
+ _pos++;\r
+ if (_pos > _posLimit)\r
+ {\r
+ const Byte *pointerToPostion = _buffer + _pos;\r
+ if(pointerToPostion > _pointerToLastSafePosition)\r
+ MoveBlock();\r
+ return ReadBlock();\r
+ }\r
+ else\r
+ return S_OK;\r
+ }\r
+ Byte GetIndexByte(Int32 index) const { return _buffer[(size_t)_pos + index]; }\r
+\r
+ // index + limit have not to exceed _keepSizeAfter;\r
+ // -2G <= index < 2G\r
+ UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit) const\r
+ { \r
+ if(_streamEndWasReached)\r
+ if ((_pos + index) + limit > _streamPos)\r
+ limit = _streamPos - (_pos + index);\r
+ distance++;\r
+ const Byte *pby = _buffer + (size_t)_pos + index;\r
+ UInt32 i;\r
+ for(i = 0; i < limit && pby[i] == pby[(size_t)i - distance]; i++);\r
+ return i;\r
+ }\r
+\r
+ UInt32 GetNumAvailableBytes() const { return _streamPos - _pos; }\r
+\r
+ void ReduceOffsets(Int32 subValue)\r
+ {\r
+ _buffer += subValue;\r
+ _posLimit -= subValue;\r
+ _pos -= subValue;\r
+ _streamPos -= subValue;\r
+ }\r
+\r
+ bool NeedMove(UInt32 numCheckBytes)\r
+ {\r
+ UInt32 reserv = _pointerToLastSafePosition - (_buffer + _pos);\r
+ return (reserv <= numCheckBytes);\r
+ }\r
+};\r
+\r
+#endif\r
--- /dev/null
+// StdAfx.h\r
+\r
+#ifndef __STDAFX_H\r
+#define __STDAFX_H\r
+\r
+#endif \r
--- /dev/null
+// LZMA.h\r
+\r
+#ifndef __LZMA_H\r
+#define __LZMA_H\r
+\r
+namespace NCompress {\r
+namespace NLZMA {\r
+\r
+const UInt32 kNumRepDistances = 4;\r
+\r
+const int kNumStates = 12;\r
+\r
+const Byte kLiteralNextStates[kNumStates] = {0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 4, 5};\r
+const Byte kMatchNextStates[kNumStates] = {7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10};\r
+const Byte kRepNextStates[kNumStates] = {8, 8, 8, 8, 8, 8, 8, 11, 11, 11, 11, 11};\r
+const Byte kShortRepNextStates[kNumStates]= {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11};\r
+\r
+class CState\r
+{\r
+public:\r
+ Byte Index;\r
+ void Init() { Index = 0; }\r
+ void UpdateChar() { Index = kLiteralNextStates[Index]; }\r
+ void UpdateMatch() { Index = kMatchNextStates[Index]; }\r
+ void UpdateRep() { Index = kRepNextStates[Index]; }\r
+ void UpdateShortRep() { Index = kShortRepNextStates[Index]; }\r
+ bool IsCharState() const { return Index < 7; }\r
+};\r
+\r
+const int kNumPosSlotBits = 6; \r
+const int kDicLogSizeMin = 0; \r
+const int kDicLogSizeMax = 32; \r
+const int kDistTableSizeMax = kDicLogSizeMax * 2; \r
+\r
+const UInt32 kNumLenToPosStates = 4;\r
+\r
+inline UInt32 GetLenToPosState(UInt32 len)\r
+{\r
+ len -= 2;\r
+ if (len < kNumLenToPosStates)\r
+ return len;\r
+ return kNumLenToPosStates - 1;\r
+}\r
+\r
+namespace NLength {\r
+\r
+const int kNumPosStatesBitsMax = 4;\r
+const UInt32 kNumPosStatesMax = (1 << kNumPosStatesBitsMax);\r
+\r
+const int kNumPosStatesBitsEncodingMax = 4;\r
+const UInt32 kNumPosStatesEncodingMax = (1 << kNumPosStatesBitsEncodingMax);\r
+\r
+const int kNumLowBits = 3;\r
+const int kNumMidBits = 3;\r
+const int kNumHighBits = 8;\r
+const UInt32 kNumLowSymbols = 1 << kNumLowBits;\r
+const UInt32 kNumMidSymbols = 1 << kNumMidBits;\r
+const UInt32 kNumSymbolsTotal = kNumLowSymbols + kNumMidSymbols + (1 << kNumHighBits);\r
+\r
+}\r
+\r
+const UInt32 kMatchMinLen = 2;\r
+const UInt32 kMatchMaxLen = kMatchMinLen + NLength::kNumSymbolsTotal - 1;\r
+\r
+const int kNumAlignBits = 4;\r
+const UInt32 kAlignTableSize = 1 << kNumAlignBits;\r
+const UInt32 kAlignMask = (kAlignTableSize - 1);\r
+\r
+const UInt32 kStartPosModelIndex = 4;\r
+const UInt32 kEndPosModelIndex = 14;\r
+const UInt32 kNumPosModels = kEndPosModelIndex - kStartPosModelIndex;\r
+\r
+const UInt32 kNumFullDistances = 1 << (kEndPosModelIndex / 2);\r
+\r
+const int kNumLitPosStatesBitsEncodingMax = 4;\r
+const int kNumLitContextBitsMax = 8;\r
+\r
+const int kNumMoveBits = 5;\r
+\r
+}}\r
+\r
+#endif\r
--- /dev/null
+// LZMA/Encoder.cpp\r
+\r
+#include "StdAfx.h"\r
+\r
+#include "../../../Common/Defs.h"\r
+#include "../../Common/StreamUtils.h"\r
+\r
+#include "LZMAEncoder.h"\r
+\r
+// for minimal compressing code size define these:\r
+// #define COMPRESS_MF_BT\r
+// #define COMPRESS_MF_BT4\r
+\r
+#if !defined(COMPRESS_MF_BT) && !defined(COMPRESS_MF_HC)\r
+#define COMPRESS_MF_BT\r
+#define COMPRESS_MF_HC\r
+#endif\r
+\r
+#ifdef COMPRESS_MF_BT\r
+#if !defined(COMPRESS_MF_BT2) && !defined(COMPRESS_MF_BT3) && !defined(COMPRESS_MF_BT4)\r
+#define COMPRESS_MF_BT2\r
+#define COMPRESS_MF_BT3\r
+#define COMPRESS_MF_BT4\r
+#endif\r
+#ifdef COMPRESS_MF_BT2\r
+#include "../LZ/BinTree/BinTree2.h"\r
+#endif\r
+#ifdef COMPRESS_MF_BT3\r
+#include "../LZ/BinTree/BinTree3.h"\r
+#endif\r
+#ifdef COMPRESS_MF_BT4\r
+#include "../LZ/BinTree/BinTree4.h"\r
+#endif\r
+#endif\r
+\r
+#ifdef COMPRESS_MF_HC\r
+#include "../LZ/HashChain/HC4.h"\r
+#endif\r
+\r
+#ifdef COMPRESS_MF_MT\r
+#include "../LZ/MT/MT.h"\r
+#endif\r
+\r
+namespace NCompress {\r
+namespace NLZMA {\r
+\r
+const int kDefaultDictionaryLogSize = 22;\r
+const UInt32 kNumFastBytesDefault = 0x20;\r
+\r
+enum \r
+{\r
+ kBT2,\r
+ kBT3,\r
+ kBT4,\r
+ kHC4\r
+};\r
+\r
+static const wchar_t *kMatchFinderIDs[] = \r
+{\r
+ L"BT2",\r
+ L"BT3",\r
+ L"BT4",\r
+ L"HC4"\r
+};\r
+\r
+Byte g_FastPos[1 << 11];\r
+\r
+class CFastPosInit\r
+{\r
+public:\r
+ CFastPosInit() { Init(); }\r
+ void Init()\r
+ {\r
+ const Byte kFastSlots = 22;\r
+ int c = 2;\r
+ g_FastPos[0] = 0;\r
+ g_FastPos[1] = 1;\r
+\r
+ for (Byte slotFast = 2; slotFast < kFastSlots; slotFast++)\r
+ {\r
+ UInt32 k = (1 << ((slotFast >> 1) - 1));\r
+ for (UInt32 j = 0; j < k; j++, c++)\r
+ g_FastPos[c] = slotFast;\r
+ }\r
+ }\r
+} g_FastPosInit;\r
+\r
+\r
+void CLiteralEncoder2::Encode(NRangeCoder::CEncoder *rangeEncoder, Byte symbol)\r
+{\r
+ UInt32 context = 1;\r
+ int i = 8;\r
+ do \r
+ {\r
+ i--;\r
+ UInt32 bit = (symbol >> i) & 1;\r
+ _encoders[context].Encode(rangeEncoder, bit);\r
+ context = (context << 1) | bit;\r
+ }\r
+ while(i != 0);\r
+}\r
+\r
+void CLiteralEncoder2::EncodeMatched(NRangeCoder::CEncoder *rangeEncoder, \r
+ Byte matchByte, Byte symbol)\r
+{\r
+ UInt32 context = 1;\r
+ int i = 8;\r
+ do \r
+ {\r
+ i--;\r
+ UInt32 bit = (symbol >> i) & 1;\r
+ UInt32 matchBit = (matchByte >> i) & 1;\r
+ _encoders[0x100 + (matchBit << 8) + context].Encode(rangeEncoder, bit);\r
+ context = (context << 1) | bit;\r
+ if (matchBit != bit)\r
+ {\r
+ while(i != 0)\r
+ {\r
+ i--;\r
+ UInt32 bit = (symbol >> i) & 1;\r
+ _encoders[context].Encode(rangeEncoder, bit);\r
+ context = (context << 1) | bit;\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ while(i != 0);\r
+}\r
+\r
+UInt32 CLiteralEncoder2::GetPrice(bool matchMode, Byte matchByte, Byte symbol) const\r
+{\r
+ UInt32 price = 0;\r
+ UInt32 context = 1;\r
+ int i = 8;\r
+ if (matchMode)\r
+ {\r
+ do \r
+ {\r
+ i--;\r
+ UInt32 matchBit = (matchByte >> i) & 1;\r
+ UInt32 bit = (symbol >> i) & 1;\r
+ price += _encoders[0x100 + (matchBit << 8) + context].GetPrice(bit);\r
+ context = (context << 1) | bit;\r
+ if (matchBit != bit)\r
+ break;\r
+ }\r
+ while (i != 0);\r
+ }\r
+ while(i != 0)\r
+ {\r
+ i--;\r
+ UInt32 bit = (symbol >> i) & 1;\r
+ price += _encoders[context].GetPrice(bit);\r
+ context = (context << 1) | bit;\r
+ }\r
+ return price;\r
+};\r
+\r
+\r
+namespace NLength {\r
+\r
+void CEncoder::Init(UInt32 numPosStates)\r
+{\r
+ _choice.Init();\r
+ _choice2.Init();\r
+ for (UInt32 posState = 0; posState < numPosStates; posState++)\r
+ {\r
+ _lowCoder[posState].Init();\r
+ _midCoder[posState].Init();\r
+ }\r
+ _highCoder.Init();\r
+}\r
+\r
+void CEncoder::Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 symbol, UInt32 posState)\r
+{\r
+ if(symbol < kNumLowSymbols)\r
+ {\r
+ _choice.Encode(rangeEncoder, 0);\r
+ _lowCoder[posState].Encode(rangeEncoder, symbol);\r
+ }\r
+ else\r
+ {\r
+ _choice.Encode(rangeEncoder, 1);\r
+ if(symbol < kNumLowSymbols + kNumMidSymbols)\r
+ {\r
+ _choice2.Encode(rangeEncoder, 0);\r
+ _midCoder[posState].Encode(rangeEncoder, symbol - kNumLowSymbols);\r
+ }\r
+ else\r
+ {\r
+ _choice2.Encode(rangeEncoder, 1);\r
+ _highCoder.Encode(rangeEncoder, symbol - kNumLowSymbols - kNumMidSymbols);\r
+ }\r
+ }\r
+}\r
+\r
+void CEncoder::SetPrices(UInt32 posState, UInt32 numSymbols, UInt32 *prices) const\r
+{\r
+ UInt32 a0 = _choice.GetPrice0();\r
+ UInt32 a1 = _choice.GetPrice1();\r
+ UInt32 b0 = a1 + _choice2.GetPrice0();\r
+ UInt32 b1 = a1 + _choice2.GetPrice1();\r
+ UInt32 i = 0;\r
+ for (i = 0; i < kNumLowSymbols; i++)\r
+ {\r
+ if (i >= numSymbols)\r
+ return;\r
+ prices[i] = a0 + _lowCoder[posState].GetPrice(i);\r
+ }\r
+ for (; i < kNumLowSymbols + kNumMidSymbols; i++)\r
+ {\r
+ if (i >= numSymbols)\r
+ return;\r
+ prices[i] = b0 + _midCoder[posState].GetPrice(i - kNumLowSymbols);\r
+ }\r
+ for (; i < numSymbols; i++)\r
+ prices[i] = b1 + _highCoder.GetPrice(i - kNumLowSymbols - kNumMidSymbols);\r
+}\r
+\r
+}\r
+CEncoder::CEncoder():\r
+ _numFastBytes(kNumFastBytesDefault),\r
+ _distTableSize(kDefaultDictionaryLogSize * 2),\r
+ _posStateBits(2),\r
+ _posStateMask(4 - 1),\r
+ _numLiteralPosStateBits(0),\r
+ _numLiteralContextBits(3),\r
+ _dictionarySize(1 << kDefaultDictionaryLogSize),\r
+ _dictionarySizePrev(UInt32(-1)),\r
+ _numFastBytesPrev(UInt32(-1)),\r
+ _matchFinderCycles(0),\r
+ _matchFinderIndex(kBT4),\r
+ #ifdef COMPRESS_MF_MT\r
+ _multiThread(false),\r
+ #endif\r
+ _writeEndMark(false),\r
+ setMfPasses(0)\r
+{\r
+ // _maxMode = false;\r
+ _fastMode = false;\r
+}\r
+\r
+HRESULT CEncoder::Create()\r
+{\r
+ if (!_rangeEncoder.Create(1 << 20))\r
+ return E_OUTOFMEMORY;\r
+ if (!_matchFinder)\r
+ {\r
+ switch(_matchFinderIndex)\r
+ {\r
+ #ifdef COMPRESS_MF_BT\r
+ #ifdef COMPRESS_MF_BT2\r
+ case kBT2:\r
+ {\r
+ NBT2::CMatchFinder *mfSpec = new NBT2::CMatchFinder;\r
+ setMfPasses = mfSpec;\r
+ _matchFinder = mfSpec;\r
+ break;\r
+ }\r
+ #endif\r
+ #ifdef COMPRESS_MF_BT3\r
+ case kBT3:\r
+ {\r
+ NBT3::CMatchFinder *mfSpec = new NBT3::CMatchFinder;\r
+ setMfPasses = mfSpec;\r
+ _matchFinder = mfSpec;\r
+ break;\r
+ }\r
+ #endif\r
+ #ifdef COMPRESS_MF_BT4\r
+ case kBT4:\r
+ {\r
+ NBT4::CMatchFinder *mfSpec = new NBT4::CMatchFinder;\r
+ setMfPasses = mfSpec;\r
+ _matchFinder = mfSpec;\r
+ break;\r
+ }\r
+ #endif\r
+ #endif\r
+ \r
+ #ifdef COMPRESS_MF_HC\r
+ case kHC4:\r
+ {\r
+ NHC4::CMatchFinder *mfSpec = new NHC4::CMatchFinder;\r
+ setMfPasses = mfSpec;\r
+ _matchFinder = mfSpec;\r
+ break;\r
+ }\r
+ #endif\r
+ }\r
+ if (_matchFinder == 0)\r
+ return E_OUTOFMEMORY;\r
+\r
+ #ifdef COMPRESS_MF_MT\r
+ if (_multiThread && !(_fastMode && (_matchFinderIndex == kHC4)))\r
+ {\r
+ CMatchFinderMT *mfSpec = new CMatchFinderMT;\r
+ if (mfSpec == 0)\r
+ return E_OUTOFMEMORY;\r
+ CMyComPtr<IMatchFinder> mf = mfSpec;\r
+ RINOK(mfSpec->SetMatchFinder(_matchFinder));\r
+ _matchFinder.Release();\r
+ _matchFinder = mf;\r
+ }\r
+ #endif\r
+ }\r
+ \r
+ if (!_literalEncoder.Create(_numLiteralPosStateBits, _numLiteralContextBits))\r
+ return E_OUTOFMEMORY;\r
+\r
+ if (_dictionarySize == _dictionarySizePrev && _numFastBytesPrev == _numFastBytes)\r
+ return S_OK;\r
+ RINOK(_matchFinder->Create(_dictionarySize, kNumOpts, _numFastBytes, kMatchMaxLen + 1)); // actually it's + _numFastBytes - _numFastBytes\r
+ if (_matchFinderCycles != 0 && setMfPasses != 0)\r
+ setMfPasses->SetNumPasses(_matchFinderCycles);\r
+ _dictionarySizePrev = _dictionarySize;\r
+ _numFastBytesPrev = _numFastBytes;\r
+ return S_OK;\r
+}\r
+\r
+static bool AreStringsEqual(const wchar_t *base, const wchar_t *testString)\r
+{\r
+ while (true)\r
+ {\r
+ wchar_t c = *testString;\r
+ if (c >= 'a' && c <= 'z')\r
+ c -= 0x20;\r
+ if (*base != c)\r
+ return false;\r
+ if (c == 0)\r
+ return true;\r
+ base++;\r
+ testString++;\r
+ }\r
+}\r
+\r
+static int FindMatchFinder(const wchar_t *s)\r
+{\r
+ for (int m = 0; m < (int)(sizeof(kMatchFinderIDs) / sizeof(kMatchFinderIDs[0])); m++)\r
+ if (AreStringsEqual(kMatchFinderIDs[m], s))\r
+ return m;\r
+ return -1;\r
+}\r
+\r
+STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs, \r
+ const PROPVARIANT *properties, UInt32 numProperties)\r
+{\r
+ for (UInt32 i = 0; i < numProperties; i++)\r
+ {\r
+ const PROPVARIANT &prop = properties[i];\r
+ switch(propIDs[i])\r
+ {\r
+ case NCoderPropID::kNumFastBytes:\r
+ {\r
+ if (prop.vt != VT_UI4)\r
+ return E_INVALIDARG;\r
+ UInt32 numFastBytes = prop.ulVal;\r
+ if(numFastBytes < 5 || numFastBytes > kMatchMaxLen)\r
+ return E_INVALIDARG;\r
+ _numFastBytes = numFastBytes;\r
+ break;\r
+ }\r
+ case NCoderPropID::kMatchFinderCycles:\r
+ {\r
+ if (prop.vt != VT_UI4)\r
+ return E_INVALIDARG;\r
+ _matchFinderCycles = prop.ulVal;\r
+ break;\r
+ }\r
+ case NCoderPropID::kAlgorithm:\r
+ {\r
+ if (prop.vt != VT_UI4)\r
+ return E_INVALIDARG;\r
+ UInt32 maximize = prop.ulVal;\r
+ _fastMode = (maximize == 0); \r
+ // _maxMode = (maximize >= 2);\r
+ break;\r
+ }\r
+ case NCoderPropID::kMatchFinder:\r
+ {\r
+ if (prop.vt != VT_BSTR)\r
+ return E_INVALIDARG;\r
+ int matchFinderIndexPrev = _matchFinderIndex;\r
+ int m = FindMatchFinder(prop.bstrVal);\r
+ if (m < 0)\r
+ return E_INVALIDARG;\r
+ _matchFinderIndex = m;\r
+ if (_matchFinder && matchFinderIndexPrev != _matchFinderIndex)\r
+ {\r
+ _dictionarySizePrev = (UInt32)-1;\r
+ ReleaseMatchFinder();\r
+ }\r
+ break;\r
+ }\r
+ #ifdef COMPRESS_MF_MT\r
+ case NCoderPropID::kMultiThread:\r
+ {\r
+ if (prop.vt != VT_BOOL)\r
+ return E_INVALIDARG;\r
+ bool newMultiThread = (prop.boolVal == VARIANT_TRUE);\r
+ if (newMultiThread != _multiThread)\r
+ {\r
+ _dictionarySizePrev = (UInt32)-1;\r
+ ReleaseMatchFinder();\r
+ _multiThread = newMultiThread;\r
+ }\r
+ break;\r
+ }\r
+ case NCoderPropID::kNumThreads:\r
+ {\r
+ if (prop.vt != VT_UI4)\r
+ return E_INVALIDARG;\r
+ bool newMultiThread = (prop.ulVal > 1);\r
+ if (newMultiThread != _multiThread)\r
+ {\r
+ _dictionarySizePrev = (UInt32)-1;\r
+ ReleaseMatchFinder();\r
+ _multiThread = newMultiThread;\r
+ }\r
+ break;\r
+ }\r
+ #endif\r
+ case NCoderPropID::kDictionarySize:\r
+ {\r
+ const int kDicLogSizeMaxCompress = 30;\r
+ if (prop.vt != VT_UI4)\r
+ return E_INVALIDARG;\r
+ UInt32 dictionarySize = prop.ulVal;\r
+ if (dictionarySize < UInt32(1 << kDicLogSizeMin) ||\r
+ dictionarySize > UInt32(1 << kDicLogSizeMaxCompress))\r
+ return E_INVALIDARG;\r
+ _dictionarySize = dictionarySize;\r
+ UInt32 dicLogSize;\r
+ for(dicLogSize = 0; dicLogSize < (UInt32)kDicLogSizeMaxCompress; dicLogSize++)\r
+ if (dictionarySize <= (UInt32(1) << dicLogSize))\r
+ break;\r
+ _distTableSize = dicLogSize * 2;\r
+ break;\r
+ }\r
+ case NCoderPropID::kPosStateBits:\r
+ {\r
+ if (prop.vt != VT_UI4)\r
+ return E_INVALIDARG;\r
+ UInt32 value = prop.ulVal;\r
+ if (value > (UInt32)NLength::kNumPosStatesBitsEncodingMax)\r
+ return E_INVALIDARG;\r
+ _posStateBits = value;\r
+ _posStateMask = (1 << _posStateBits) - 1;\r
+ break;\r
+ }\r
+ case NCoderPropID::kLitPosBits:\r
+ {\r
+ if (prop.vt != VT_UI4)\r
+ return E_INVALIDARG;\r
+ UInt32 value = prop.ulVal;\r
+ if (value > (UInt32)kNumLitPosStatesBitsEncodingMax)\r
+ return E_INVALIDARG;\r
+ _numLiteralPosStateBits = value;\r
+ break;\r
+ }\r
+ case NCoderPropID::kLitContextBits:\r
+ {\r
+ if (prop.vt != VT_UI4)\r
+ return E_INVALIDARG;\r
+ UInt32 value = prop.ulVal;\r
+ if (value > (UInt32)kNumLitContextBitsMax)\r
+ return E_INVALIDARG;\r
+ _numLiteralContextBits = value;\r
+ break;\r
+ }\r
+ case NCoderPropID::kEndMarker:\r
+ {\r
+ if (prop.vt != VT_BOOL)\r
+ return E_INVALIDARG;\r
+ SetWriteEndMarkerMode(prop.boolVal == VARIANT_TRUE);\r
+ break;\r
+ }\r
+ default:\r
+ return E_INVALIDARG;\r
+ }\r
+ }\r
+ return S_OK;\r
+}\r
+\r
+STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream)\r
+{ \r
+ const UInt32 kPropSize = 5;\r
+ Byte properties[kPropSize];\r
+ properties[0] = (_posStateBits * 5 + _numLiteralPosStateBits) * 9 + _numLiteralContextBits;\r
+ for (int i = 0; i < 4; i++)\r
+ properties[1 + i] = Byte(_dictionarySize >> (8 * i));\r
+ return WriteStream(outStream, properties, kPropSize, NULL);\r
+}\r
+\r
+STDMETHODIMP CEncoder::SetOutStream(ISequentialOutStream *outStream)\r
+{\r
+ _rangeEncoder.SetStream(outStream);\r
+ return S_OK;\r
+}\r
+\r
+STDMETHODIMP CEncoder::ReleaseOutStream()\r
+{\r
+ _rangeEncoder.ReleaseStream();\r
+ return S_OK;\r
+}\r
+\r
+HRESULT CEncoder::Init()\r
+{\r
+ CBaseState::Init();\r
+\r
+ // RINOK(_matchFinder->Init(inStream));\r
+ _rangeEncoder.Init();\r
+\r
+ for(int i = 0; i < kNumStates; i++)\r
+ {\r
+ for (UInt32 j = 0; j <= _posStateMask; j++)\r
+ {\r
+ _isMatch[i][j].Init();\r
+ _isRep0Long[i][j].Init();\r
+ }\r
+ _isRep[i].Init();\r
+ _isRepG0[i].Init();\r
+ _isRepG1[i].Init();\r
+ _isRepG2[i].Init();\r
+ }\r
+\r
+ _literalEncoder.Init();\r
+\r
+ {\r
+ for(UInt32 i = 0; i < kNumLenToPosStates; i++)\r
+ _posSlotEncoder[i].Init();\r
+ }\r
+ {\r
+ for(UInt32 i = 0; i < kNumFullDistances - kEndPosModelIndex; i++)\r
+ _posEncoders[i].Init();\r
+ }\r
+\r
+ _lenEncoder.Init(1 << _posStateBits);\r
+ _repMatchLenEncoder.Init(1 << _posStateBits);\r
+\r
+ _posAlignEncoder.Init();\r
+\r
+ _longestMatchWasFound = false;\r
+ _optimumEndIndex = 0;\r
+ _optimumCurrentIndex = 0;\r
+ _additionalOffset = 0;\r
+\r
+ return S_OK;\r
+}\r
+\r
+HRESULT CEncoder::MovePos(UInt32 num)\r
+{\r
+ if (num == 0)\r
+ return S_OK;\r
+ _additionalOffset += num;\r
+ return _matchFinder->Skip(num);\r
+}\r
+\r
+UInt32 CEncoder::Backward(UInt32 &backRes, UInt32 cur)\r
+{\r
+ _optimumEndIndex = cur;\r
+ UInt32 posMem = _optimum[cur].PosPrev;\r
+ UInt32 backMem = _optimum[cur].BackPrev;\r
+ do\r
+ {\r
+ if (_optimum[cur].Prev1IsChar)\r
+ {\r
+ _optimum[posMem].MakeAsChar();\r
+ _optimum[posMem].PosPrev = posMem - 1;\r
+ if (_optimum[cur].Prev2)\r
+ {\r
+ _optimum[posMem - 1].Prev1IsChar = false;\r
+ _optimum[posMem - 1].PosPrev = _optimum[cur].PosPrev2;\r
+ _optimum[posMem - 1].BackPrev = _optimum[cur].BackPrev2;\r
+ }\r
+ }\r
+ UInt32 posPrev = posMem;\r
+ UInt32 backCur = backMem;\r
+\r
+ backMem = _optimum[posPrev].BackPrev;\r
+ posMem = _optimum[posPrev].PosPrev;\r
+\r
+ _optimum[posPrev].BackPrev = backCur;\r
+ _optimum[posPrev].PosPrev = cur;\r
+ cur = posPrev;\r
+ }\r
+ while(cur != 0);\r
+ backRes = _optimum[0].BackPrev;\r
+ _optimumCurrentIndex = _optimum[0].PosPrev;\r
+ return _optimumCurrentIndex; \r
+}\r
+\r
+/*\r
+Out:\r
+ (lenRes == 1) && (backRes == 0xFFFFFFFF) means Literal\r
+*/\r
+\r
+HRESULT CEncoder::GetOptimum(UInt32 position, UInt32 &backRes, UInt32 &lenRes)\r
+{\r
+ if(_optimumEndIndex != _optimumCurrentIndex)\r
+ {\r
+ const COptimal &optimum = _optimum[_optimumCurrentIndex];\r
+ lenRes = optimum.PosPrev - _optimumCurrentIndex;\r
+ backRes = optimum.BackPrev;\r
+ _optimumCurrentIndex = optimum.PosPrev;\r
+ return S_OK;\r
+ }\r
+ _optimumCurrentIndex = _optimumEndIndex = 0;\r
+ \r
+ UInt32 lenMain, numDistancePairs;\r
+ if (!_longestMatchWasFound)\r
+ {\r
+ RINOK(ReadMatchDistances(lenMain, numDistancePairs));\r
+ }\r
+ else\r
+ {\r
+ lenMain = _longestMatchLength;\r
+ numDistancePairs = _numDistancePairs;\r
+ _longestMatchWasFound = false;\r
+ }\r
+\r
+ const Byte *data = _matchFinder->GetPointerToCurrentPos() - 1;\r
+ UInt32 numAvailableBytes = _matchFinder->GetNumAvailableBytes() + 1;\r
+ if (numAvailableBytes < 2)\r
+ {\r
+ backRes = (UInt32)(-1);\r
+ lenRes = 1;\r
+ return S_OK;\r
+ }\r
+ if (numAvailableBytes > kMatchMaxLen)\r
+ numAvailableBytes = kMatchMaxLen;\r
+\r
+ UInt32 reps[kNumRepDistances];\r
+ UInt32 repLens[kNumRepDistances];\r
+ UInt32 repMaxIndex = 0;\r
+ UInt32 i;\r
+ for(i = 0; i < kNumRepDistances; i++)\r
+ {\r
+ reps[i] = _repDistances[i];\r
+ UInt32 backOffset = reps[i] + 1;\r
+ if (data[0] != data[(size_t)0 - backOffset] || data[1] != data[(size_t)1 - backOffset])\r
+ {\r
+ repLens[i] = 0;\r
+ continue;\r
+ }\r
+ UInt32 lenTest;\r
+ for (lenTest = 2; lenTest < numAvailableBytes && \r
+ data[lenTest] == data[(size_t)lenTest - backOffset]; lenTest++);\r
+ repLens[i] = lenTest;\r
+ if (lenTest > repLens[repMaxIndex])\r
+ repMaxIndex = i;\r
+ }\r
+ if(repLens[repMaxIndex] >= _numFastBytes)\r
+ {\r
+ backRes = repMaxIndex;\r
+ lenRes = repLens[repMaxIndex];\r
+ return MovePos(lenRes - 1);\r
+ }\r
+\r
+ UInt32 *matchDistances = _matchDistances + 1;\r
+ if(lenMain >= _numFastBytes)\r
+ {\r
+ backRes = matchDistances[numDistancePairs - 1] + kNumRepDistances; \r
+ lenRes = lenMain;\r
+ return MovePos(lenMain - 1);\r
+ }\r
+ Byte currentByte = *data;\r
+ Byte matchByte = data[(size_t)0 - reps[0] - 1];\r
+\r
+ if(lenMain < 2 && currentByte != matchByte && repLens[repMaxIndex] < 2)\r
+ {\r
+ backRes = (UInt32)-1;\r
+ lenRes = 1;\r
+ return S_OK;\r
+ }\r
+\r
+ _optimum[0].State = _state;\r
+\r
+ UInt32 posState = (position & _posStateMask);\r
+\r
+ _optimum[1].Price = _isMatch[_state.Index][posState].GetPrice0() + \r
+ _literalEncoder.GetSubCoder(position, _previousByte)->GetPrice(!_state.IsCharState(), matchByte, currentByte);\r
+ _optimum[1].MakeAsChar();\r
+\r
+ UInt32 matchPrice = _isMatch[_state.Index][posState].GetPrice1();\r
+ UInt32 repMatchPrice = matchPrice + _isRep[_state.Index].GetPrice1();\r
+\r
+ if(matchByte == currentByte)\r
+ {\r
+ UInt32 shortRepPrice = repMatchPrice + GetRepLen1Price(_state, posState);\r
+ if(shortRepPrice < _optimum[1].Price)\r
+ {\r
+ _optimum[1].Price = shortRepPrice;\r
+ _optimum[1].MakeAsShortRep();\r
+ }\r
+ }\r
+ UInt32 lenEnd = ((lenMain >= repLens[repMaxIndex]) ? lenMain : repLens[repMaxIndex]);\r
+\r
+ if(lenEnd < 2)\r
+ {\r
+ backRes = _optimum[1].BackPrev;\r
+ lenRes = 1;\r
+ return S_OK;\r
+ }\r
+\r
+ _optimum[1].PosPrev = 0;\r
+ for (i = 0; i < kNumRepDistances; i++)\r
+ _optimum[0].Backs[i] = reps[i];\r
+\r
+ UInt32 len = lenEnd;\r
+ do\r
+ _optimum[len--].Price = kIfinityPrice;\r
+ while (len >= 2);\r
+\r
+ for(i = 0; i < kNumRepDistances; i++)\r
+ {\r
+ UInt32 repLen = repLens[i];\r
+ if (repLen < 2)\r
+ continue;\r
+ UInt32 price = repMatchPrice + GetPureRepPrice(i, _state, posState);\r
+ do\r
+ {\r
+ UInt32 curAndLenPrice = price + _repMatchLenEncoder.GetPrice(repLen - 2, posState);\r
+ COptimal &optimum = _optimum[repLen];\r
+ if (curAndLenPrice < optimum.Price) \r
+ {\r
+ optimum.Price = curAndLenPrice;\r
+ optimum.PosPrev = 0;\r
+ optimum.BackPrev = i;\r
+ optimum.Prev1IsChar = false;\r
+ }\r
+ }\r
+ while(--repLen >= 2);\r
+ }\r
+\r
+ UInt32 normalMatchPrice = matchPrice + _isRep[_state.Index].GetPrice0();\r
+\r
+ len = ((repLens[0] >= 2) ? repLens[0] + 1 : 2);\r
+ if (len <= lenMain)\r
+ {\r
+ UInt32 offs = 0;\r
+ while (len > matchDistances[offs])\r
+ offs += 2;\r
+ for(; ; len++)\r
+ {\r
+ UInt32 distance = matchDistances[offs + 1];\r
+ UInt32 curAndLenPrice = normalMatchPrice + GetPosLenPrice(distance, len, posState);\r
+ COptimal &optimum = _optimum[len];\r
+ if (curAndLenPrice < optimum.Price) \r
+ {\r
+ optimum.Price = curAndLenPrice;\r
+ optimum.PosPrev = 0;\r
+ optimum.BackPrev = distance + kNumRepDistances;\r
+ optimum.Prev1IsChar = false;\r
+ }\r
+ if (len == matchDistances[offs])\r
+ {\r
+ offs += 2;\r
+ if (offs == numDistancePairs)\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ UInt32 cur = 0;\r
+\r
+ while(true)\r
+ {\r
+ cur++;\r
+ if(cur == lenEnd)\r
+ {\r
+ lenRes = Backward(backRes, cur);\r
+ return S_OK;\r
+ }\r
+ UInt32 newLen, numDistancePairs;\r
+ RINOK(ReadMatchDistances(newLen, numDistancePairs));\r
+ if(newLen >= _numFastBytes)\r
+ {\r
+ _numDistancePairs = numDistancePairs;\r
+ _longestMatchLength = newLen;\r
+ _longestMatchWasFound = true;\r
+ lenRes = Backward(backRes, cur);\r
+ return S_OK;\r
+ }\r
+ position++;\r
+ COptimal &curOptimum = _optimum[cur];\r
+ UInt32 posPrev = curOptimum.PosPrev;\r
+ CState state;\r
+ if (curOptimum.Prev1IsChar)\r
+ {\r
+ posPrev--;\r
+ if (curOptimum.Prev2)\r
+ {\r
+ state = _optimum[curOptimum.PosPrev2].State;\r
+ if (curOptimum.BackPrev2 < kNumRepDistances)\r
+ state.UpdateRep();\r
+ else\r
+ state.UpdateMatch();\r
+ }\r
+ else\r
+ state = _optimum[posPrev].State;\r
+ state.UpdateChar();\r
+ }\r
+ else\r
+ state = _optimum[posPrev].State;\r
+ if (posPrev == cur - 1)\r
+ {\r
+ if (curOptimum.IsShortRep())\r
+ state.UpdateShortRep();\r
+ else\r
+ state.UpdateChar();\r
+ }\r
+ else\r
+ {\r
+ UInt32 pos;\r
+ if (curOptimum.Prev1IsChar && curOptimum.Prev2)\r
+ {\r
+ posPrev = curOptimum.PosPrev2;\r
+ pos = curOptimum.BackPrev2;\r
+ state.UpdateRep();\r
+ }\r
+ else\r
+ {\r
+ pos = curOptimum.BackPrev;\r
+ if (pos < kNumRepDistances)\r
+ state.UpdateRep();\r
+ else\r
+ state.UpdateMatch();\r
+ }\r
+ const COptimal &prevOptimum = _optimum[posPrev];\r
+ if (pos < kNumRepDistances)\r
+ {\r
+ reps[0] = prevOptimum.Backs[pos];\r
+ UInt32 i;\r
+ for(i = 1; i <= pos; i++)\r
+ reps[i] = prevOptimum.Backs[i - 1];\r
+ for(; i < kNumRepDistances; i++)\r
+ reps[i] = prevOptimum.Backs[i];\r
+ }\r
+ else\r
+ {\r
+ reps[0] = (pos - kNumRepDistances);\r
+ for(UInt32 i = 1; i < kNumRepDistances; i++)\r
+ reps[i] = prevOptimum.Backs[i - 1];\r
+ }\r
+ }\r
+ curOptimum.State = state;\r
+ for(UInt32 i = 0; i < kNumRepDistances; i++)\r
+ curOptimum.Backs[i] = reps[i];\r
+ UInt32 curPrice = curOptimum.Price; \r
+ const Byte *data = _matchFinder->GetPointerToCurrentPos() - 1;\r
+ const Byte currentByte = *data;\r
+ const Byte matchByte = data[(size_t)0 - reps[0] - 1];\r
+\r
+ UInt32 posState = (position & _posStateMask);\r
+\r
+ UInt32 curAnd1Price = curPrice +\r
+ _isMatch[state.Index][posState].GetPrice0() +\r
+ _literalEncoder.GetSubCoder(position, data[(size_t)0 - 1])->GetPrice(!state.IsCharState(), matchByte, currentByte);\r
+\r
+ COptimal &nextOptimum = _optimum[cur + 1];\r
+\r
+ bool nextIsChar = false;\r
+ if (curAnd1Price < nextOptimum.Price) \r
+ {\r
+ nextOptimum.Price = curAnd1Price;\r
+ nextOptimum.PosPrev = cur;\r
+ nextOptimum.MakeAsChar();\r
+ nextIsChar = true;\r
+ }\r
+\r
+ UInt32 matchPrice = curPrice + _isMatch[state.Index][posState].GetPrice1();\r
+ UInt32 repMatchPrice = matchPrice + _isRep[state.Index].GetPrice1();\r
+ \r
+ if(matchByte == currentByte &&\r
+ !(nextOptimum.PosPrev < cur && nextOptimum.BackPrev == 0))\r
+ {\r
+ UInt32 shortRepPrice = repMatchPrice + GetRepLen1Price(state, posState);\r
+ if(shortRepPrice <= nextOptimum.Price)\r
+ {\r
+ nextOptimum.Price = shortRepPrice;\r
+ nextOptimum.PosPrev = cur;\r
+ nextOptimum.MakeAsShortRep();\r
+ nextIsChar = true;\r
+ }\r
+ }\r
+ /*\r
+ if(newLen == 2 && matchDistances[2] >= kDistLimit2) // test it maybe set 2000 ?\r
+ continue;\r
+ */\r
+\r
+ UInt32 numAvailableBytesFull = _matchFinder->GetNumAvailableBytes() + 1;\r
+ numAvailableBytesFull = MyMin(kNumOpts - 1 - cur, numAvailableBytesFull);\r
+ UInt32 numAvailableBytes = numAvailableBytesFull;\r
+\r
+ if (numAvailableBytes < 2)\r
+ continue;\r
+ if (numAvailableBytes > _numFastBytes)\r
+ numAvailableBytes = _numFastBytes;\r
+ if (!nextIsChar && matchByte != currentByte) // speed optimization\r
+ {\r
+ // try Literal + rep0\r
+ UInt32 backOffset = reps[0] + 1;\r
+ UInt32 limit = MyMin(numAvailableBytesFull, _numFastBytes + 1);\r
+ UInt32 temp;\r
+ for (temp = 1; temp < limit && \r
+ data[temp] == data[(size_t)temp - backOffset]; temp++);\r
+ UInt32 lenTest2 = temp - 1;\r
+ if (lenTest2 >= 2)\r
+ {\r
+ CState state2 = state;\r
+ state2.UpdateChar();\r
+ UInt32 posStateNext = (position + 1) & _posStateMask;\r
+ UInt32 nextRepMatchPrice = curAnd1Price + \r
+ _isMatch[state2.Index][posStateNext].GetPrice1() +\r
+ _isRep[state2.Index].GetPrice1();\r
+ // for (; lenTest2 >= 2; lenTest2--)\r
+ {\r
+ UInt32 offset = cur + 1 + lenTest2;\r
+ while(lenEnd < offset)\r
+ _optimum[++lenEnd].Price = kIfinityPrice;\r
+ UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(\r
+ 0, lenTest2, state2, posStateNext);\r
+ COptimal &optimum = _optimum[offset];\r
+ if (curAndLenPrice < optimum.Price) \r
+ {\r
+ optimum.Price = curAndLenPrice;\r
+ optimum.PosPrev = cur + 1;\r
+ optimum.BackPrev = 0;\r
+ optimum.Prev1IsChar = true;\r
+ optimum.Prev2 = false;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ \r
+ UInt32 startLen = 2; // speed optimization \r
+ for(UInt32 repIndex = 0; repIndex < kNumRepDistances; repIndex++)\r
+ {\r
+ // UInt32 repLen = _matchFinder->GetMatchLen(0 - 1, reps[repIndex], newLen); // test it;\r
+ UInt32 backOffset = reps[repIndex] + 1;\r
+ if (data[0] != data[(size_t)0 - backOffset] ||\r
+ data[1] != data[(size_t)1 - backOffset])\r
+ continue;\r
+ UInt32 lenTest;\r
+ for (lenTest = 2; lenTest < numAvailableBytes && \r
+ data[lenTest] == data[(size_t)lenTest - backOffset]; lenTest++);\r
+ while(lenEnd < cur + lenTest)\r
+ _optimum[++lenEnd].Price = kIfinityPrice;\r
+ UInt32 lenTestTemp = lenTest;\r
+ UInt32 price = repMatchPrice + GetPureRepPrice(repIndex, state, posState);\r
+ do\r
+ {\r
+ UInt32 curAndLenPrice = price + _repMatchLenEncoder.GetPrice(lenTest - 2, posState);\r
+ COptimal &optimum = _optimum[cur + lenTest];\r
+ if (curAndLenPrice < optimum.Price) \r
+ {\r
+ optimum.Price = curAndLenPrice;\r
+ optimum.PosPrev = cur;\r
+ optimum.BackPrev = repIndex;\r
+ optimum.Prev1IsChar = false;\r
+ }\r
+ }\r
+ while(--lenTest >= 2);\r
+ lenTest = lenTestTemp;\r
+ \r
+ if (repIndex == 0)\r
+ startLen = lenTest + 1;\r
+ \r
+ // if (_maxMode)\r
+ {\r
+ UInt32 lenTest2 = lenTest + 1;\r
+ UInt32 limit = MyMin(numAvailableBytesFull, lenTest2 + _numFastBytes);\r
+ for (; lenTest2 < limit && \r
+ data[lenTest2] == data[(size_t)lenTest2 - backOffset]; lenTest2++);\r
+ lenTest2 -= lenTest + 1;\r
+ if (lenTest2 >= 2)\r
+ {\r
+ CState state2 = state;\r
+ state2.UpdateRep();\r
+ UInt32 posStateNext = (position + lenTest) & _posStateMask;\r
+ UInt32 curAndLenCharPrice = \r
+ price + _repMatchLenEncoder.GetPrice(lenTest - 2, posState) + \r
+ _isMatch[state2.Index][posStateNext].GetPrice0() +\r
+ _literalEncoder.GetSubCoder(position + lenTest, data[(size_t)lenTest - 1])->GetPrice(\r
+ true, data[(size_t)lenTest - backOffset], data[lenTest]);\r
+ state2.UpdateChar();\r
+ posStateNext = (position + lenTest + 1) & _posStateMask;\r
+ UInt32 nextRepMatchPrice = curAndLenCharPrice + \r
+ _isMatch[state2.Index][posStateNext].GetPrice1() +\r
+ _isRep[state2.Index].GetPrice1();\r
+ \r
+ // for(; lenTest2 >= 2; lenTest2--)\r
+ {\r
+ UInt32 offset = cur + lenTest + 1 + lenTest2;\r
+ while(lenEnd < offset)\r
+ _optimum[++lenEnd].Price = kIfinityPrice;\r
+ UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(\r
+ 0, lenTest2, state2, posStateNext);\r
+ COptimal &optimum = _optimum[offset];\r
+ if (curAndLenPrice < optimum.Price) \r
+ {\r
+ optimum.Price = curAndLenPrice;\r
+ optimum.PosPrev = cur + lenTest + 1;\r
+ optimum.BackPrev = 0;\r
+ optimum.Prev1IsChar = true;\r
+ optimum.Prev2 = true;\r
+ optimum.PosPrev2 = cur;\r
+ optimum.BackPrev2 = repIndex;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ \r
+ // for(UInt32 lenTest = 2; lenTest <= newLen; lenTest++)\r
+ if (newLen > numAvailableBytes)\r
+ {\r
+ newLen = numAvailableBytes;\r
+ for (numDistancePairs = 0; newLen > matchDistances[numDistancePairs]; numDistancePairs += 2);\r
+ matchDistances[numDistancePairs] = newLen;\r
+ numDistancePairs += 2;\r
+ }\r
+ if (newLen >= startLen)\r
+ {\r
+ UInt32 normalMatchPrice = matchPrice + _isRep[state.Index].GetPrice0();\r
+ while(lenEnd < cur + newLen)\r
+ _optimum[++lenEnd].Price = kIfinityPrice;\r
+\r
+ UInt32 offs = 0;\r
+ while(startLen > matchDistances[offs])\r
+ offs += 2;\r
+ UInt32 curBack = matchDistances[offs + 1];\r
+ UInt32 posSlot = GetPosSlot2(curBack);\r
+ for(UInt32 lenTest = /*2*/ startLen; ; lenTest++)\r
+ {\r
+ UInt32 curAndLenPrice = normalMatchPrice;\r
+ UInt32 lenToPosState = GetLenToPosState(lenTest);\r
+ if (curBack < kNumFullDistances)\r
+ curAndLenPrice += _distancesPrices[lenToPosState][curBack];\r
+ else\r
+ curAndLenPrice += _posSlotPrices[lenToPosState][posSlot] + _alignPrices[curBack & kAlignMask];\r
+ \r
+ curAndLenPrice += _lenEncoder.GetPrice(lenTest - kMatchMinLen, posState);\r
+ \r
+ COptimal &optimum = _optimum[cur + lenTest];\r
+ if (curAndLenPrice < optimum.Price) \r
+ {\r
+ optimum.Price = curAndLenPrice;\r
+ optimum.PosPrev = cur;\r
+ optimum.BackPrev = curBack + kNumRepDistances;\r
+ optimum.Prev1IsChar = false;\r
+ }\r
+\r
+ if (/*_maxMode && */lenTest == matchDistances[offs])\r
+ {\r
+ // Try Match + Literal + Rep0\r
+ UInt32 backOffset = curBack + 1;\r
+ UInt32 lenTest2 = lenTest + 1;\r
+ UInt32 limit = MyMin(numAvailableBytesFull, lenTest2 + _numFastBytes);\r
+ for (; lenTest2 < limit && \r
+ data[lenTest2] == data[(size_t)lenTest2 - backOffset]; lenTest2++);\r
+ lenTest2 -= lenTest + 1;\r
+ if (lenTest2 >= 2)\r
+ {\r
+ CState state2 = state;\r
+ state2.UpdateMatch();\r
+ UInt32 posStateNext = (position + lenTest) & _posStateMask;\r
+ UInt32 curAndLenCharPrice = curAndLenPrice + \r
+ _isMatch[state2.Index][posStateNext].GetPrice0() +\r
+ _literalEncoder.GetSubCoder(position + lenTest, data[(size_t)lenTest - 1])->GetPrice( \r
+ true, data[(size_t)lenTest - backOffset], data[lenTest]);\r
+ state2.UpdateChar();\r
+ posStateNext = (posStateNext + 1) & _posStateMask;\r
+ UInt32 nextRepMatchPrice = curAndLenCharPrice + \r
+ _isMatch[state2.Index][posStateNext].GetPrice1() +\r
+ _isRep[state2.Index].GetPrice1();\r
+ \r
+ // for(; lenTest2 >= 2; lenTest2--)\r
+ {\r
+ UInt32 offset = cur + lenTest + 1 + lenTest2;\r
+ while(lenEnd < offset)\r
+ _optimum[++lenEnd].Price = kIfinityPrice;\r
+ UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(0, lenTest2, state2, posStateNext);\r
+ COptimal &optimum = _optimum[offset];\r
+ if (curAndLenPrice < optimum.Price) \r
+ {\r
+ optimum.Price = curAndLenPrice;\r
+ optimum.PosPrev = cur + lenTest + 1;\r
+ optimum.BackPrev = 0;\r
+ optimum.Prev1IsChar = true;\r
+ optimum.Prev2 = true;\r
+ optimum.PosPrev2 = cur;\r
+ optimum.BackPrev2 = curBack + kNumRepDistances;\r
+ }\r
+ }\r
+ }\r
+ offs += 2;\r
+ if (offs == numDistancePairs)\r
+ break;\r
+ curBack = matchDistances[offs + 1];\r
+ if (curBack >= kNumFullDistances)\r
+ posSlot = GetPosSlot2(curBack);\r
+ }\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+static inline bool ChangePair(UInt32 smallDist, UInt32 bigDist)\r
+{\r
+ return ((bigDist >> 7) > smallDist);\r
+}\r
+\r
+\r
+HRESULT CEncoder::ReadMatchDistances(UInt32 &lenRes, UInt32 &numDistancePairs)\r
+{\r
+ lenRes = 0;\r
+ RINOK(_matchFinder->GetMatches(_matchDistances));\r
+ numDistancePairs = _matchDistances[0];\r
+ if (numDistancePairs > 0)\r
+ {\r
+ lenRes = _matchDistances[1 + numDistancePairs - 2];\r
+ if (lenRes == _numFastBytes)\r
+ lenRes += _matchFinder->GetMatchLen(lenRes - 1, _matchDistances[1 + numDistancePairs - 1], \r
+ kMatchMaxLen - lenRes);\r
+ }\r
+ _additionalOffset++;\r
+ return S_OK;\r
+}\r
+\r
+HRESULT CEncoder::GetOptimumFast(UInt32 position, UInt32 &backRes, UInt32 &lenRes)\r
+{\r
+ UInt32 lenMain, numDistancePairs;\r
+ if (!_longestMatchWasFound)\r
+ {\r
+ RINOK(ReadMatchDistances(lenMain, numDistancePairs));\r
+ }\r
+ else\r
+ {\r
+ lenMain = _longestMatchLength;\r
+ numDistancePairs = _numDistancePairs;\r
+ _longestMatchWasFound = false;\r
+ }\r
+\r
+ const Byte *data = _matchFinder->GetPointerToCurrentPos() - 1;\r
+ UInt32 numAvailableBytes = _matchFinder->GetNumAvailableBytes() + 1;\r
+ if (numAvailableBytes > kMatchMaxLen)\r
+ numAvailableBytes = kMatchMaxLen;\r
+ if (numAvailableBytes < 2)\r
+ {\r
+ backRes = (UInt32)(-1);\r
+ lenRes = 1;\r
+ return S_OK;\r
+ }\r
+\r
+ UInt32 repLens[kNumRepDistances];\r
+ UInt32 repMaxIndex = 0;\r
+\r
+ for(UInt32 i = 0; i < kNumRepDistances; i++)\r
+ {\r
+ UInt32 backOffset = _repDistances[i] + 1;\r
+ if (data[0] != data[(size_t)0 - backOffset] || data[1] != data[(size_t)1 - backOffset])\r
+ {\r
+ repLens[i] = 0;\r
+ continue;\r
+ }\r
+ UInt32 len;\r
+ for (len = 2; len < numAvailableBytes && data[len] == data[(size_t)len - backOffset]; len++);\r
+ if(len >= _numFastBytes)\r
+ {\r
+ backRes = i;\r
+ lenRes = len;\r
+ return MovePos(lenRes - 1);\r
+ }\r
+ repLens[i] = len;\r
+ if (len > repLens[repMaxIndex])\r
+ repMaxIndex = i;\r
+ }\r
+ UInt32 *matchDistances = _matchDistances + 1;\r
+ if(lenMain >= _numFastBytes)\r
+ {\r
+ backRes = matchDistances[numDistancePairs - 1] + kNumRepDistances; \r
+ lenRes = lenMain;\r
+ return MovePos(lenMain - 1);\r
+ }\r
+\r
+ UInt32 backMain = 0;\r
+ if (lenMain >= 2)\r
+ {\r
+ backMain = matchDistances[numDistancePairs - 1];\r
+ while (numDistancePairs > 2 && lenMain == matchDistances[numDistancePairs - 4] + 1)\r
+ {\r
+ if (!ChangePair(matchDistances[numDistancePairs - 3], backMain))\r
+ break;\r
+ numDistancePairs -= 2;\r
+ lenMain = matchDistances[numDistancePairs - 2];\r
+ backMain = matchDistances[numDistancePairs - 1];\r
+ }\r
+ if (lenMain == 2 && backMain >= 0x80)\r
+ lenMain = 1;\r
+ }\r
+\r
+ if (repLens[repMaxIndex] >= 2)\r
+ {\r
+ if (repLens[repMaxIndex] + 1 >= lenMain || \r
+ repLens[repMaxIndex] + 2 >= lenMain && (backMain > (1 << 9)) ||\r
+ repLens[repMaxIndex] + 3 >= lenMain && (backMain > (1 << 15)))\r
+ {\r
+ backRes = repMaxIndex;\r
+ lenRes = repLens[repMaxIndex];\r
+ return MovePos(lenRes - 1);\r
+ }\r
+ }\r
+ \r
+ if (lenMain >= 2 && numAvailableBytes > 2)\r
+ {\r
+ RINOK(ReadMatchDistances(_longestMatchLength, _numDistancePairs));\r
+ if (_longestMatchLength >= 2)\r
+ {\r
+ UInt32 newDistance = matchDistances[_numDistancePairs - 1];\r
+ if (_longestMatchLength >= lenMain && newDistance < backMain || \r
+ _longestMatchLength == lenMain + 1 && !ChangePair(backMain, newDistance) ||\r
+ _longestMatchLength > lenMain + 1 ||\r
+ _longestMatchLength + 1 >= lenMain && lenMain >= 3 && ChangePair(newDistance, backMain))\r
+ {\r
+ _longestMatchWasFound = true;\r
+ backRes = UInt32(-1);\r
+ lenRes = 1;\r
+ return S_OK;\r
+ }\r
+ }\r
+ data++;\r
+ numAvailableBytes--;\r
+ for(UInt32 i = 0; i < kNumRepDistances; i++)\r
+ {\r
+ UInt32 backOffset = _repDistances[i] + 1;\r
+ if (data[1] != data[(size_t)1 - backOffset] || data[2] != data[(size_t)2 - backOffset])\r
+ {\r
+ repLens[i] = 0;\r
+ continue;\r
+ }\r
+ UInt32 len;\r
+ for (len = 2; len < numAvailableBytes && data[len] == data[(size_t)len - backOffset]; len++);\r
+ if (len + 1 >= lenMain)\r
+ {\r
+ _longestMatchWasFound = true;\r
+ backRes = UInt32(-1);\r
+ lenRes = 1;\r
+ return S_OK;\r
+ }\r
+ }\r
+ backRes = backMain + kNumRepDistances; \r
+ lenRes = lenMain;\r
+ return MovePos(lenMain - 2);\r
+ }\r
+ backRes = UInt32(-1);\r
+ lenRes = 1;\r
+ return S_OK;\r
+}\r
+\r
+HRESULT CEncoder::Flush(UInt32 nowPos)\r
+{\r
+ ReleaseMFStream();\r
+ WriteEndMarker(nowPos & _posStateMask);\r
+ _rangeEncoder.FlushData();\r
+ return _rangeEncoder.FlushStream();\r
+}\r
+\r
+void CEncoder::WriteEndMarker(UInt32 posState)\r
+{\r
+ // This function for writing End Mark for stream version of LZMA. \r
+ // In current version this feature is not used.\r
+ if (!_writeEndMark)\r
+ return;\r
+\r
+ _isMatch[_state.Index][posState].Encode(&_rangeEncoder, 1);\r
+ _isRep[_state.Index].Encode(&_rangeEncoder, 0);\r
+ _state.UpdateMatch();\r
+ UInt32 len = kMatchMinLen; // kMatchMaxLen;\r
+ _lenEncoder.Encode(&_rangeEncoder, len - kMatchMinLen, posState, !_fastMode);\r
+ UInt32 posSlot = (1 << kNumPosSlotBits) - 1;\r
+ UInt32 lenToPosState = GetLenToPosState(len);\r
+ _posSlotEncoder[lenToPosState].Encode(&_rangeEncoder, posSlot);\r
+ UInt32 footerBits = 30;\r
+ UInt32 posReduced = (UInt32(1) << footerBits) - 1;\r
+ _rangeEncoder.EncodeDirectBits(posReduced >> kNumAlignBits, footerBits - kNumAlignBits);\r
+ _posAlignEncoder.ReverseEncode(&_rangeEncoder, posReduced & kAlignMask);\r
+}\r
+\r
+HRESULT CEncoder::CodeReal(ISequentialInStream *inStream,\r
+ ISequentialOutStream *outStream, \r
+ const UInt64 *inSize, const UInt64 *outSize,\r
+ ICompressProgressInfo *progress)\r
+{\r
+ _needReleaseMFStream = false;\r
+ CCoderReleaser coderReleaser(this);\r
+ RINOK(SetStreams(inStream, outStream, inSize, outSize));\r
+ while(true)\r
+ {\r
+ UInt64 processedInSize;\r
+ UInt64 processedOutSize;\r
+ Int32 finished;\r
+ RINOK(CodeOneBlock(&processedInSize, &processedOutSize, &finished));\r
+ if (finished != 0)\r
+ return S_OK;\r
+ if (progress != 0)\r
+ {\r
+ RINOK(progress->SetRatioInfo(&processedInSize, &processedOutSize));\r
+ }\r
+ }\r
+}\r
+\r
+HRESULT CEncoder::SetStreams(ISequentialInStream *inStream,\r
+ ISequentialOutStream *outStream, \r
+ const UInt64 *inSize, const UInt64 *outSize)\r
+{\r
+ _inStream = inStream;\r
+ _finished = false;\r
+ RINOK(Create());\r
+ RINOK(SetOutStream(outStream));\r
+ RINOK(Init());\r
+ \r
+ // CCoderReleaser releaser(this);\r
+\r
+ /*\r
+ if (_matchFinder->GetNumAvailableBytes() == 0)\r
+ return Flush();\r
+ */\r
+\r
+ if (!_fastMode)\r
+ {\r
+ FillDistancesPrices();\r
+ FillAlignPrices();\r
+ }\r
+\r
+ _lenEncoder.SetTableSize(_numFastBytes + 1 - kMatchMinLen);\r
+ _lenEncoder.UpdateTables(1 << _posStateBits);\r
+ _repMatchLenEncoder.SetTableSize(_numFastBytes + 1 - kMatchMinLen);\r
+ _repMatchLenEncoder.UpdateTables(1 << _posStateBits);\r
+\r
+ nowPos64 = 0;\r
+ return S_OK;\r
+}\r
+\r
+HRESULT CEncoder::CodeOneBlock(UInt64 *inSize, UInt64 *outSize, Int32 *finished)\r
+{\r
+ if (_inStream != 0)\r
+ {\r
+ RINOK(_matchFinder->SetStream(_inStream));\r
+ RINOK(_matchFinder->Init());\r
+ _needReleaseMFStream = true;\r
+ _inStream = 0;\r
+ }\r
+\r
+\r
+ *finished = 1;\r
+ if (_finished)\r
+ return S_OK;\r
+ _finished = true;\r
+\r
+ if (nowPos64 == 0)\r
+ {\r
+ if (_matchFinder->GetNumAvailableBytes() == 0)\r
+ return Flush(UInt32(nowPos64));\r
+ UInt32 len, numDistancePairs;\r
+ RINOK(ReadMatchDistances(len, numDistancePairs));\r
+ UInt32 posState = UInt32(nowPos64) & _posStateMask;\r
+ _isMatch[_state.Index][posState].Encode(&_rangeEncoder, 0);\r
+ _state.UpdateChar();\r
+ Byte curByte = _matchFinder->GetIndexByte(0 - _additionalOffset);\r
+ _literalEncoder.GetSubCoder(UInt32(nowPos64), _previousByte)->Encode(&_rangeEncoder, curByte);\r
+ _previousByte = curByte;\r
+ _additionalOffset--;\r
+ nowPos64++;\r
+ }\r
+\r
+ UInt32 nowPos32 = (UInt32)nowPos64;\r
+ UInt32 progressPosValuePrev = nowPos32;\r
+\r
+ if (_matchFinder->GetNumAvailableBytes() == 0)\r
+ return Flush(nowPos32);\r
+\r
+ while(true)\r
+ {\r
+ #ifdef _NO_EXCEPTIONS\r
+ if (_rangeEncoder.Stream.ErrorCode != S_OK)\r
+ return _rangeEncoder.Stream.ErrorCode;\r
+ #endif\r
+ UInt32 pos, len;\r
+ HRESULT result;\r
+ if (_fastMode)\r
+ result = GetOptimumFast(nowPos32, pos, len);\r
+ else\r
+ result = GetOptimum(nowPos32, pos, len);\r
+ RINOK(result);\r
+\r
+ UInt32 posState = nowPos32 & _posStateMask;\r
+ if(len == 1 && pos == 0xFFFFFFFF)\r
+ {\r
+ _isMatch[_state.Index][posState].Encode(&_rangeEncoder, 0);\r
+ Byte curByte = _matchFinder->GetIndexByte(0 - _additionalOffset);\r
+ CLiteralEncoder2 *subCoder = _literalEncoder.GetSubCoder(nowPos32, _previousByte);\r
+ if(_state.IsCharState())\r
+ subCoder->Encode(&_rangeEncoder, curByte);\r
+ else\r
+ {\r
+ Byte matchByte = _matchFinder->GetIndexByte(0 - _repDistances[0] - 1 - _additionalOffset);\r
+ subCoder->EncodeMatched(&_rangeEncoder, matchByte, curByte);\r
+ }\r
+ _state.UpdateChar();\r
+ _previousByte = curByte;\r
+ }\r
+ else\r
+ {\r
+ _isMatch[_state.Index][posState].Encode(&_rangeEncoder, 1);\r
+ if(pos < kNumRepDistances)\r
+ {\r
+ _isRep[_state.Index].Encode(&_rangeEncoder, 1);\r
+ if(pos == 0)\r
+ {\r
+ _isRepG0[_state.Index].Encode(&_rangeEncoder, 0);\r
+ _isRep0Long[_state.Index][posState].Encode(&_rangeEncoder, ((len == 1) ? 0 : 1));\r
+ }\r
+ else\r
+ {\r
+ UInt32 distance = _repDistances[pos];\r
+ _isRepG0[_state.Index].Encode(&_rangeEncoder, 1);\r
+ if (pos == 1)\r
+ _isRepG1[_state.Index].Encode(&_rangeEncoder, 0);\r
+ else\r
+ {\r
+ _isRepG1[_state.Index].Encode(&_rangeEncoder, 1);\r
+ _isRepG2[_state.Index].Encode(&_rangeEncoder, pos - 2);\r
+ if (pos == 3)\r
+ _repDistances[3] = _repDistances[2];\r
+ _repDistances[2] = _repDistances[1];\r
+ }\r
+ _repDistances[1] = _repDistances[0];\r
+ _repDistances[0] = distance;\r
+ }\r
+ if (len == 1)\r
+ _state.UpdateShortRep();\r
+ else\r
+ {\r
+ _repMatchLenEncoder.Encode(&_rangeEncoder, len - kMatchMinLen, posState, !_fastMode);\r
+ _state.UpdateRep();\r
+ }\r
+ }\r
+ else\r
+ {\r
+ _isRep[_state.Index].Encode(&_rangeEncoder, 0);\r
+ _state.UpdateMatch();\r
+ _lenEncoder.Encode(&_rangeEncoder, len - kMatchMinLen, posState, !_fastMode);\r
+ pos -= kNumRepDistances;\r
+ UInt32 posSlot = GetPosSlot(pos);\r
+ _posSlotEncoder[GetLenToPosState(len)].Encode(&_rangeEncoder, posSlot);\r
+ \r
+ if (posSlot >= kStartPosModelIndex)\r
+ {\r
+ UInt32 footerBits = ((posSlot >> 1) - 1);\r
+ UInt32 base = ((2 | (posSlot & 1)) << footerBits);\r
+ UInt32 posReduced = pos - base;\r
+\r
+ if (posSlot < kEndPosModelIndex)\r
+ NRangeCoder::ReverseBitTreeEncode(_posEncoders + base - posSlot - 1, \r
+ &_rangeEncoder, footerBits, posReduced);\r
+ else\r
+ {\r
+ _rangeEncoder.EncodeDirectBits(posReduced >> kNumAlignBits, footerBits - kNumAlignBits);\r
+ _posAlignEncoder.ReverseEncode(&_rangeEncoder, posReduced & kAlignMask);\r
+ _alignPriceCount++;\r
+ }\r
+ }\r
+ _repDistances[3] = _repDistances[2];\r
+ _repDistances[2] = _repDistances[1];\r
+ _repDistances[1] = _repDistances[0];\r
+ _repDistances[0] = pos;\r
+ _matchPriceCount++;\r
+ }\r
+ _previousByte = _matchFinder->GetIndexByte(len - 1 - _additionalOffset);\r
+ }\r
+ _additionalOffset -= len;\r
+ nowPos32 += len;\r
+ if (_additionalOffset == 0)\r
+ {\r
+ if (!_fastMode)\r
+ {\r
+ if (_matchPriceCount >= (1 << 7))\r
+ FillDistancesPrices();\r
+ if (_alignPriceCount >= kAlignTableSize)\r
+ FillAlignPrices();\r
+ }\r
+ if (_matchFinder->GetNumAvailableBytes() == 0)\r
+ return Flush(nowPos32);\r
+ if (nowPos32 - progressPosValuePrev >= (1 << 14))\r
+ {\r
+ nowPos64 += nowPos32 - progressPosValuePrev;\r
+ *inSize = nowPos64;\r
+ *outSize = _rangeEncoder.GetProcessedSize();\r
+ _finished = false;\r
+ *finished = 0;\r
+ return S_OK;\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+STDMETHODIMP CEncoder::Code(ISequentialInStream *inStream,\r
+ ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,\r
+ ICompressProgressInfo *progress)\r
+{\r
+ #ifndef _NO_EXCEPTIONS\r
+ try \r
+ { \r
+ #endif\r
+ return CodeReal(inStream, outStream, inSize, outSize, progress); \r
+ #ifndef _NO_EXCEPTIONS\r
+ }\r
+ catch(const COutBufferException &e) { return e.ErrorCode; }\r
+ catch(...) { return E_FAIL; }\r
+ #endif\r
+}\r
+ \r
+void CEncoder::FillDistancesPrices()\r
+{\r
+ UInt32 tempPrices[kNumFullDistances];\r
+ for (UInt32 i = kStartPosModelIndex; i < kNumFullDistances; i++)\r
+ { \r
+ UInt32 posSlot = GetPosSlot(i);\r
+ UInt32 footerBits = ((posSlot >> 1) - 1);\r
+ UInt32 base = ((2 | (posSlot & 1)) << footerBits);\r
+ tempPrices[i] = NRangeCoder::ReverseBitTreeGetPrice(_posEncoders + \r
+ base - posSlot - 1, footerBits, i - base);\r
+ }\r
+\r
+ for (UInt32 lenToPosState = 0; lenToPosState < kNumLenToPosStates; lenToPosState++)\r
+ {\r
+ UInt32 posSlot;\r
+ NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumPosSlotBits> &encoder = _posSlotEncoder[lenToPosState];\r
+ UInt32 *posSlotPrices = _posSlotPrices[lenToPosState];\r
+ for (posSlot = 0; posSlot < _distTableSize; posSlot++)\r
+ posSlotPrices[posSlot] = encoder.GetPrice(posSlot);\r
+ for (posSlot = kEndPosModelIndex; posSlot < _distTableSize; posSlot++)\r
+ posSlotPrices[posSlot] += ((((posSlot >> 1) - 1) - kNumAlignBits) << NRangeCoder::kNumBitPriceShiftBits);\r
+\r
+ UInt32 *distancesPrices = _distancesPrices[lenToPosState];\r
+ UInt32 i;\r
+ for (i = 0; i < kStartPosModelIndex; i++)\r
+ distancesPrices[i] = posSlotPrices[i];\r
+ for (; i < kNumFullDistances; i++)\r
+ distancesPrices[i] = posSlotPrices[GetPosSlot(i)] + tempPrices[i];\r
+ }\r
+ _matchPriceCount = 0;\r
+}\r
+\r
+void CEncoder::FillAlignPrices()\r
+{\r
+ for (UInt32 i = 0; i < kAlignTableSize; i++)\r
+ _alignPrices[i] = _posAlignEncoder.ReverseGetPrice(i);\r
+ _alignPriceCount = 0;\r
+}\r
+\r
+}}\r
--- /dev/null
+// LZMA/Encoder.h\r
+\r
+#ifndef __LZMA_ENCODER_H\r
+#define __LZMA_ENCODER_H\r
+\r
+#include "../../../Common/MyCom.h"\r
+#include "../../../Common/Alloc.h"\r
+#include "../../ICoder.h"\r
+#include "../LZ/IMatchFinder.h"\r
+#include "../RangeCoder/RangeCoderBitTree.h"\r
+\r
+#include "LZMA.h"\r
+\r
+namespace NCompress {\r
+namespace NLZMA {\r
+\r
+typedef NRangeCoder::CBitEncoder<kNumMoveBits> CMyBitEncoder;\r
+\r
+class CBaseState\r
+{\r
+protected:\r
+ CState _state;\r
+ Byte _previousByte;\r
+ UInt32 _repDistances[kNumRepDistances];\r
+ void Init()\r
+ {\r
+ _state.Init();\r
+ _previousByte = 0;\r
+ for(UInt32 i = 0 ; i < kNumRepDistances; i++)\r
+ _repDistances[i] = 0;\r
+ }\r
+};\r
+\r
+struct COptimal\r
+{\r
+ CState State;\r
+\r
+ bool Prev1IsChar;\r
+ bool Prev2;\r
+\r
+ UInt32 PosPrev2;\r
+ UInt32 BackPrev2; \r
+\r
+ UInt32 Price; \r
+ UInt32 PosPrev; // posNext;\r
+ UInt32 BackPrev; \r
+ UInt32 Backs[kNumRepDistances];\r
+ void MakeAsChar() { BackPrev = UInt32(-1); Prev1IsChar = false; }\r
+ void MakeAsShortRep() { BackPrev = 0; ; Prev1IsChar = false; }\r
+ bool IsShortRep() { return (BackPrev == 0); }\r
+};\r
+\r
+\r
+extern Byte g_FastPos[1 << 11];\r
+inline UInt32 GetPosSlot(UInt32 pos)\r
+{\r
+ if (pos < (1 << 11))\r
+ return g_FastPos[pos];\r
+ if (pos < (1 << 21))\r
+ return g_FastPos[pos >> 10] + 20;\r
+ return g_FastPos[pos >> 20] + 40;\r
+}\r
+\r
+inline UInt32 GetPosSlot2(UInt32 pos)\r
+{\r
+ if (pos < (1 << 17))\r
+ return g_FastPos[pos >> 6] + 12;\r
+ if (pos < (1 << 27))\r
+ return g_FastPos[pos >> 16] + 32;\r
+ return g_FastPos[pos >> 26] + 52;\r
+}\r
+\r
+const UInt32 kIfinityPrice = 0xFFFFFFF;\r
+\r
+const UInt32 kNumOpts = 1 << 12;\r
+\r
+\r
+class CLiteralEncoder2\r
+{\r
+ CMyBitEncoder _encoders[0x300];\r
+public:\r
+ void Init()\r
+ {\r
+ for (int i = 0; i < 0x300; i++)\r
+ _encoders[i].Init();\r
+ }\r
+ void Encode(NRangeCoder::CEncoder *rangeEncoder, Byte symbol);\r
+ void EncodeMatched(NRangeCoder::CEncoder *rangeEncoder, Byte matchByte, Byte symbol);\r
+ UInt32 GetPrice(bool matchMode, Byte matchByte, Byte symbol) const;\r
+};\r
+\r
+class CLiteralEncoder\r
+{\r
+ CLiteralEncoder2 *_coders;\r
+ int _numPrevBits;\r
+ int _numPosBits;\r
+ UInt32 _posMask;\r
+public:\r
+ CLiteralEncoder(): _coders(0) {}\r
+ ~CLiteralEncoder() { Free(); }\r
+ void Free()\r
+ { \r
+ MyFree(_coders);\r
+ _coders = 0;\r
+ }\r
+ bool Create(int numPosBits, int numPrevBits)\r
+ {\r
+ if (_coders == 0 || (numPosBits + numPrevBits) != (_numPrevBits + _numPosBits))\r
+ {\r
+ Free();\r
+ UInt32 numStates = 1 << (numPosBits + numPrevBits);\r
+ _coders = (CLiteralEncoder2 *)MyAlloc(numStates * sizeof(CLiteralEncoder2));\r
+ }\r
+ _numPosBits = numPosBits;\r
+ _posMask = (1 << numPosBits) - 1;\r
+ _numPrevBits = numPrevBits;\r
+ return (_coders != 0);\r
+ }\r
+ void Init()\r
+ {\r
+ UInt32 numStates = 1 << (_numPrevBits + _numPosBits);\r
+ for (UInt32 i = 0; i < numStates; i++)\r
+ _coders[i].Init();\r
+ }\r
+ CLiteralEncoder2 *GetSubCoder(UInt32 pos, Byte prevByte)\r
+ { return &_coders[((pos & _posMask) << _numPrevBits) + (prevByte >> (8 - _numPrevBits))]; }\r
+};\r
+\r
+namespace NLength {\r
+\r
+class CEncoder\r
+{\r
+ CMyBitEncoder _choice;\r
+ CMyBitEncoder _choice2;\r
+ NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumLowBits> _lowCoder[kNumPosStatesEncodingMax];\r
+ NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumMidBits> _midCoder[kNumPosStatesEncodingMax];\r
+ NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumHighBits> _highCoder;\r
+public:\r
+ void Init(UInt32 numPosStates);\r
+ void Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 symbol, UInt32 posState);\r
+ void SetPrices(UInt32 posState, UInt32 numSymbols, UInt32 *prices) const;\r
+};\r
+\r
+const UInt32 kNumSpecSymbols = kNumLowSymbols + kNumMidSymbols;\r
+\r
+class CPriceTableEncoder: public CEncoder\r
+{\r
+ UInt32 _prices[kNumPosStatesEncodingMax][kNumSymbolsTotal];\r
+ UInt32 _tableSize;\r
+ UInt32 _counters[kNumPosStatesEncodingMax];\r
+public:\r
+ void SetTableSize(UInt32 tableSize) { _tableSize = tableSize; }\r
+ UInt32 GetPrice(UInt32 symbol, UInt32 posState) const { return _prices[posState][symbol]; }\r
+ void UpdateTable(UInt32 posState)\r
+ {\r
+ SetPrices(posState, _tableSize, _prices[posState]);\r
+ _counters[posState] = _tableSize;\r
+ }\r
+ void UpdateTables(UInt32 numPosStates)\r
+ {\r
+ for (UInt32 posState = 0; posState < numPosStates; posState++)\r
+ UpdateTable(posState);\r
+ }\r
+ void Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 symbol, UInt32 posState, bool updatePrice)\r
+ {\r
+ CEncoder::Encode(rangeEncoder, symbol, posState);\r
+ if (updatePrice)\r
+ if (--_counters[posState] == 0)\r
+ UpdateTable(posState);\r
+ }\r
+};\r
+\r
+}\r
+\r
+class CEncoder : \r
+ public ICompressCoder,\r
+ public ICompressSetOutStream,\r
+ public ICompressSetCoderProperties,\r
+ public ICompressWriteCoderProperties,\r
+ public CBaseState,\r
+ public CMyUnknownImp\r
+{\r
+ COptimal _optimum[kNumOpts];\r
+ CMyComPtr<IMatchFinder> _matchFinder; // test it\r
+ NRangeCoder::CEncoder _rangeEncoder;\r
+\r
+ CMyBitEncoder _isMatch[kNumStates][NLength::kNumPosStatesEncodingMax];\r
+ CMyBitEncoder _isRep[kNumStates];\r
+ CMyBitEncoder _isRepG0[kNumStates];\r
+ CMyBitEncoder _isRepG1[kNumStates];\r
+ CMyBitEncoder _isRepG2[kNumStates];\r
+ CMyBitEncoder _isRep0Long[kNumStates][NLength::kNumPosStatesEncodingMax];\r
+\r
+ NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumPosSlotBits> _posSlotEncoder[kNumLenToPosStates];\r
+\r
+ CMyBitEncoder _posEncoders[kNumFullDistances - kEndPosModelIndex];\r
+ NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumAlignBits> _posAlignEncoder;\r
+ \r
+ NLength::CPriceTableEncoder _lenEncoder;\r
+ NLength::CPriceTableEncoder _repMatchLenEncoder;\r
+\r
+ CLiteralEncoder _literalEncoder;\r
+\r
+ UInt32 _matchDistances[kMatchMaxLen * 2 + 2 + 1];\r
+\r
+ bool _fastMode;\r
+ // bool _maxMode;\r
+ UInt32 _numFastBytes;\r
+ UInt32 _longestMatchLength; \r
+ UInt32 _numDistancePairs;\r
+\r
+ UInt32 _additionalOffset;\r
+\r
+ UInt32 _optimumEndIndex;\r
+ UInt32 _optimumCurrentIndex;\r
+\r
+ bool _longestMatchWasFound;\r
+\r
+ UInt32 _posSlotPrices[kNumLenToPosStates][kDistTableSizeMax];\r
+ \r
+ UInt32 _distancesPrices[kNumLenToPosStates][kNumFullDistances];\r
+\r
+ UInt32 _alignPrices[kAlignTableSize];\r
+ UInt32 _alignPriceCount;\r
+\r
+ UInt32 _distTableSize;\r
+\r
+ UInt32 _posStateBits;\r
+ UInt32 _posStateMask;\r
+ UInt32 _numLiteralPosStateBits;\r
+ UInt32 _numLiteralContextBits;\r
+\r
+ UInt32 _dictionarySize;\r
+\r
+ UInt32 _dictionarySizePrev;\r
+ UInt32 _numFastBytesPrev;\r
+\r
+ UInt32 _matchPriceCount;\r
+ UInt64 nowPos64;\r
+ bool _finished;\r
+ ISequentialInStream *_inStream;\r
+\r
+ UInt32 _matchFinderCycles;\r
+ int _matchFinderIndex;\r
+ #ifdef COMPRESS_MF_MT\r
+ bool _multiThread;\r
+ #endif\r
+\r
+ bool _writeEndMark;\r
+\r
+ bool _needReleaseMFStream;\r
+\r
+ IMatchFinderSetNumPasses *setMfPasses;\r
+\r
+ void ReleaseMatchFinder()\r
+ {\r
+ setMfPasses = 0;\r
+ _matchFinder.Release();\r
+ }\r
+ \r
+ HRESULT ReadMatchDistances(UInt32 &len, UInt32 &numDistancePairs);\r
+\r
+ HRESULT MovePos(UInt32 num);\r
+ UInt32 GetRepLen1Price(CState state, UInt32 posState) const\r
+ {\r
+ return _isRepG0[state.Index].GetPrice0() +\r
+ _isRep0Long[state.Index][posState].GetPrice0();\r
+ }\r
+ \r
+ UInt32 GetPureRepPrice(UInt32 repIndex, CState state, UInt32 posState) const\r
+ {\r
+ UInt32 price;\r
+ if(repIndex == 0)\r
+ {\r
+ price = _isRepG0[state.Index].GetPrice0();\r
+ price += _isRep0Long[state.Index][posState].GetPrice1();\r
+ }\r
+ else\r
+ {\r
+ price = _isRepG0[state.Index].GetPrice1();\r
+ if (repIndex == 1)\r
+ price += _isRepG1[state.Index].GetPrice0();\r
+ else\r
+ {\r
+ price += _isRepG1[state.Index].GetPrice1();\r
+ price += _isRepG2[state.Index].GetPrice(repIndex - 2);\r
+ }\r
+ }\r
+ return price;\r
+ }\r
+ UInt32 GetRepPrice(UInt32 repIndex, UInt32 len, CState state, UInt32 posState) const\r
+ {\r
+ return _repMatchLenEncoder.GetPrice(len - kMatchMinLen, posState) +\r
+ GetPureRepPrice(repIndex, state, posState);\r
+ }\r
+ /*\r
+ UInt32 GetPosLen2Price(UInt32 pos, UInt32 posState) const\r
+ {\r
+ if (pos >= kNumFullDistances)\r
+ return kIfinityPrice;\r
+ return _distancesPrices[0][pos] + _lenEncoder.GetPrice(0, posState);\r
+ }\r
+ UInt32 GetPosLen3Price(UInt32 pos, UInt32 len, UInt32 posState) const\r
+ {\r
+ UInt32 price;\r
+ UInt32 lenToPosState = GetLenToPosState(len);\r
+ if (pos < kNumFullDistances)\r
+ price = _distancesPrices[lenToPosState][pos];\r
+ else\r
+ price = _posSlotPrices[lenToPosState][GetPosSlot2(pos)] + \r
+ _alignPrices[pos & kAlignMask];\r
+ return price + _lenEncoder.GetPrice(len - kMatchMinLen, posState);\r
+ }\r
+ */\r
+ UInt32 GetPosLenPrice(UInt32 pos, UInt32 len, UInt32 posState) const\r
+ {\r
+ UInt32 price;\r
+ UInt32 lenToPosState = GetLenToPosState(len);\r
+ if (pos < kNumFullDistances)\r
+ price = _distancesPrices[lenToPosState][pos];\r
+ else\r
+ price = _posSlotPrices[lenToPosState][GetPosSlot2(pos)] + \r
+ _alignPrices[pos & kAlignMask];\r
+ return price + _lenEncoder.GetPrice(len - kMatchMinLen, posState);\r
+ }\r
+\r
+ UInt32 Backward(UInt32 &backRes, UInt32 cur);\r
+ HRESULT GetOptimum(UInt32 position, UInt32 &backRes, UInt32 &lenRes);\r
+ HRESULT GetOptimumFast(UInt32 position, UInt32 &backRes, UInt32 &lenRes);\r
+\r
+ void FillDistancesPrices();\r
+ void FillAlignPrices();\r
+ \r
+ void ReleaseMFStream()\r
+ {\r
+ if (_matchFinder && _needReleaseMFStream)\r
+ {\r
+ _matchFinder->ReleaseStream();\r
+ _needReleaseMFStream = false;\r
+ }\r
+ }\r
+\r
+ void ReleaseStreams()\r
+ {\r
+ ReleaseMFStream();\r
+ ReleaseOutStream();\r
+ }\r
+\r
+ HRESULT Flush(UInt32 nowPos);\r
+ class CCoderReleaser\r
+ {\r
+ CEncoder *_coder;\r
+ public:\r
+ CCoderReleaser(CEncoder *coder): _coder(coder) {}\r
+ ~CCoderReleaser()\r
+ {\r
+ _coder->ReleaseStreams();\r
+ }\r
+ };\r
+ friend class CCoderReleaser;\r
+\r
+ void WriteEndMarker(UInt32 posState);\r
+\r
+public:\r
+ CEncoder();\r
+ void SetWriteEndMarkerMode(bool writeEndMarker)\r
+ { _writeEndMark= writeEndMarker; }\r
+\r
+ HRESULT Create();\r
+\r
+ MY_UNKNOWN_IMP3(\r
+ ICompressSetOutStream,\r
+ ICompressSetCoderProperties,\r
+ ICompressWriteCoderProperties\r
+ )\r
+ \r
+ HRESULT Init();\r
+ \r
+ // ICompressCoder interface\r
+ HRESULT SetStreams(ISequentialInStream *inStream,\r
+ ISequentialOutStream *outStream,\r
+ const UInt64 *inSize, const UInt64 *outSize);\r
+ HRESULT CodeOneBlock(UInt64 *inSize, UInt64 *outSize, Int32 *finished);\r
+\r
+ HRESULT CodeReal(ISequentialInStream *inStream,\r
+ ISequentialOutStream *outStream, \r
+ const UInt64 *inSize, const UInt64 *outSize,\r
+ ICompressProgressInfo *progress);\r
+\r
+ // ICompressCoder interface\r
+ STDMETHOD(Code)(ISequentialInStream *inStream,\r
+ ISequentialOutStream *outStream, \r
+ const UInt64 *inSize, const UInt64 *outSize,\r
+ ICompressProgressInfo *progress);\r
+\r
+ // ICompressSetCoderProperties2\r
+ STDMETHOD(SetCoderProperties)(const PROPID *propIDs, \r
+ const PROPVARIANT *properties, UInt32 numProperties);\r
+ \r
+ // ICompressWriteCoderProperties\r
+ STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);\r
+\r
+ STDMETHOD(SetOutStream)(ISequentialOutStream *outStream);\r
+ STDMETHOD(ReleaseOutStream)();\r
+\r
+ virtual ~CEncoder() {}\r
+};\r
+\r
+}}\r
+\r
+#endif\r
--- /dev/null
+// StdAfx.h\r
+\r
+#ifndef __STDAFX_H\r
+#define __STDAFX_H\r
+\r
+#include "../../../Common/MyWindows.h"\r
+\r
+#endif\r
--- /dev/null
+// Compress/RangeCoder/RangeCoder.h\r
+\r
+#ifndef __COMPRESS_RANGECODER_H\r
+#define __COMPRESS_RANGECODER_H\r
+\r
+#include "../../Common/InBuffer.h"\r
+#include "../../Common/OutBuffer.h"\r
+\r
+namespace NCompress {\r
+namespace NRangeCoder {\r
+\r
+const int kNumTopBits = 24;\r
+const UInt32 kTopValue = (1 << kNumTopBits);\r
+\r
+class CEncoder\r
+{\r
+ UInt32 _cacheSize;\r
+ Byte _cache;\r
+public:\r
+ UInt64 Low;\r
+ UInt32 Range;\r
+ COutBuffer Stream;\r
+ bool Create(UInt32 bufferSize) { return Stream.Create(bufferSize); }\r
+\r
+ void SetStream(ISequentialOutStream *stream) { Stream.SetStream(stream); }\r
+ void Init()\r
+ {\r
+ Stream.Init();\r
+ Low = 0;\r
+ Range = 0xFFFFFFFF;\r
+ _cacheSize = 1;\r
+ _cache = 0;\r
+ }\r
+\r
+ void FlushData()\r
+ {\r
+ // Low += 1; \r
+ for(int i = 0; i < 5; i++)\r
+ ShiftLow();\r
+ }\r
+\r
+ HRESULT FlushStream() { return Stream.Flush(); }\r
+\r
+ void ReleaseStream() { Stream.ReleaseStream(); }\r
+\r
+ void Encode(UInt32 start, UInt32 size, UInt32 total)\r
+ {\r
+ Low += start * (Range /= total);\r
+ Range *= size;\r
+ while (Range < kTopValue)\r
+ {\r
+ Range <<= 8;\r
+ ShiftLow();\r
+ }\r
+ }\r
+\r
+ void ShiftLow()\r
+ {\r
+ if ((UInt32)Low < (UInt32)0xFF000000 || (int)(Low >> 32) != 0) \r
+ {\r
+ Byte temp = _cache;\r
+ do\r
+ {\r
+ Stream.WriteByte((Byte)(temp + (Byte)(Low >> 32)));\r
+ temp = 0xFF;\r
+ }\r
+ while(--_cacheSize != 0);\r
+ _cache = (Byte)((UInt32)Low >> 24); \r
+ } \r
+ _cacheSize++; \r
+ Low = (UInt32)Low << 8; \r
+ }\r
+ \r
+ void EncodeDirectBits(UInt32 value, int numTotalBits)\r
+ {\r
+ for (int i = numTotalBits - 1; i >= 0; i--)\r
+ {\r
+ Range >>= 1;\r
+ if (((value >> i) & 1) == 1)\r
+ Low += Range;\r
+ if (Range < kTopValue)\r
+ {\r
+ Range <<= 8;\r
+ ShiftLow();\r
+ }\r
+ }\r
+ }\r
+\r
+ void EncodeBit(UInt32 size0, UInt32 numTotalBits, UInt32 symbol)\r
+ {\r
+ UInt32 newBound = (Range >> numTotalBits) * size0;\r
+ if (symbol == 0)\r
+ Range = newBound;\r
+ else\r
+ {\r
+ Low += newBound;\r
+ Range -= newBound;\r
+ }\r
+ while (Range < kTopValue)\r
+ {\r
+ Range <<= 8;\r
+ ShiftLow();\r
+ }\r
+ }\r
+\r
+ UInt64 GetProcessedSize() { return Stream.GetProcessedSize() + _cacheSize + 4; }\r
+};\r
+\r
+class CDecoder\r
+{\r
+public:\r
+ CInBuffer Stream;\r
+ UInt32 Range;\r
+ UInt32 Code;\r
+ bool Create(UInt32 bufferSize) { return Stream.Create(bufferSize); }\r
+\r
+ void Normalize()\r
+ {\r
+ while (Range < kTopValue)\r
+ {\r
+ Code = (Code << 8) | Stream.ReadByte();\r
+ Range <<= 8;\r
+ }\r
+ }\r
+ \r
+ void SetStream(ISequentialInStream *stream) { Stream.SetStream(stream); }\r
+ void Init()\r
+ {\r
+ Stream.Init();\r
+ Code = 0;\r
+ Range = 0xFFFFFFFF;\r
+ for(int i = 0; i < 5; i++)\r
+ Code = (Code << 8) | Stream.ReadByte();\r
+ }\r
+\r
+ void ReleaseStream() { Stream.ReleaseStream(); }\r
+\r
+ UInt32 GetThreshold(UInt32 total)\r
+ {\r
+ return (Code) / ( Range /= total);\r
+ }\r
+\r
+ void Decode(UInt32 start, UInt32 size)\r
+ {\r
+ Code -= start * Range;\r
+ Range *= size;\r
+ Normalize();\r
+ }\r
+\r
+ UInt32 DecodeDirectBits(int numTotalBits)\r
+ {\r
+ UInt32 range = Range;\r
+ UInt32 code = Code; \r
+ UInt32 result = 0;\r
+ for (int i = numTotalBits; i != 0; i--)\r
+ {\r
+ range >>= 1;\r
+ /*\r
+ result <<= 1;\r
+ if (code >= range)\r
+ {\r
+ code -= range;\r
+ result |= 1;\r
+ }\r
+ */\r
+ UInt32 t = (code - range) >> 31;\r
+ code -= range & (t - 1);\r
+ result = (result << 1) | (1 - t);\r
+\r
+ if (range < kTopValue)\r
+ {\r
+ code = (code << 8) | Stream.ReadByte();\r
+ range <<= 8; \r
+ }\r
+ }\r
+ Range = range;\r
+ Code = code;\r
+ return result;\r
+ }\r
+\r
+ UInt32 DecodeBit(UInt32 size0, UInt32 numTotalBits)\r
+ {\r
+ UInt32 newBound = (Range >> numTotalBits) * size0;\r
+ UInt32 symbol;\r
+ if (Code < newBound)\r
+ {\r
+ symbol = 0;\r
+ Range = newBound;\r
+ }\r
+ else\r
+ {\r
+ symbol = 1;\r
+ Code -= newBound;\r
+ Range -= newBound;\r
+ }\r
+ Normalize();\r
+ return symbol;\r
+ }\r
+\r
+ UInt64 GetProcessedSize() {return Stream.GetProcessedSize(); }\r
+};\r
+\r
+}}\r
+\r
+#endif\r
--- /dev/null
+// Compress/RangeCoder/RangeCoderBit.cpp\r
+\r
+#include "StdAfx.h"\r
+\r
+#include "RangeCoderBit.h"\r
+\r
+namespace NCompress {\r
+namespace NRangeCoder {\r
+\r
+UInt32 CPriceTables::ProbPrices[kBitModelTotal >> kNumMoveReducingBits];\r
+static CPriceTables g_PriceTables;\r
+\r
+CPriceTables::CPriceTables() { Init(); }\r
+\r
+void CPriceTables::Init()\r
+{\r
+ const int kNumBits = (kNumBitModelTotalBits - kNumMoveReducingBits);\r
+ for(int i = kNumBits - 1; i >= 0; i--)\r
+ {\r
+ UInt32 start = 1 << (kNumBits - i - 1);\r
+ UInt32 end = 1 << (kNumBits - i);\r
+ for (UInt32 j = start; j < end; j++)\r
+ ProbPrices[j] = (i << kNumBitPriceShiftBits) + \r
+ (((end - j) << kNumBitPriceShiftBits) >> (kNumBits - i - 1));\r
+ }\r
+\r
+ /*\r
+ // simplest: bad solution\r
+ for(UInt32 i = 1; i < (kBitModelTotal >> kNumMoveReducingBits) - 1; i++)\r
+ ProbPrices[i] = kBitPrice;\r
+ */\r
+ \r
+ /*\r
+ const double kDummyMultMid = (1.0 / kBitPrice) / 2;\r
+ const double kDummyMultMid = 0;\r
+ // float solution\r
+ double ln2 = log(double(2));\r
+ double lnAll = log(double(kBitModelTotal >> kNumMoveReducingBits));\r
+ for(UInt32 i = 1; i < (kBitModelTotal >> kNumMoveReducingBits) - 1; i++)\r
+ ProbPrices[i] = UInt32((fabs(lnAll - log(double(i))) / ln2 + kDummyMultMid) * kBitPrice);\r
+ */\r
+ \r
+ /*\r
+ // experimental, slow, solution:\r
+ for(UInt32 i = 1; i < (kBitModelTotal >> kNumMoveReducingBits) - 1; i++)\r
+ {\r
+ const int kCyclesBits = 5;\r
+ const UInt32 kCycles = (1 << kCyclesBits);\r
+\r
+ UInt32 range = UInt32(-1);\r
+ UInt32 bitCount = 0;\r
+ for (UInt32 j = 0; j < kCycles; j++)\r
+ {\r
+ range >>= (kNumBitModelTotalBits - kNumMoveReducingBits);\r
+ range *= i;\r
+ while(range < (1 << 31))\r
+ {\r
+ range <<= 1;\r
+ bitCount++;\r
+ }\r
+ }\r
+ bitCount <<= kNumBitPriceShiftBits;\r
+ range -= (1 << 31);\r
+ for (int k = kNumBitPriceShiftBits - 1; k >= 0; k--)\r
+ {\r
+ range <<= 1;\r
+ if (range > (1 << 31))\r
+ {\r
+ bitCount += (1 << k);\r
+ range -= (1 << 31);\r
+ }\r
+ }\r
+ ProbPrices[i] = (bitCount \r
+ // + (1 << (kCyclesBits - 1))\r
+ ) >> kCyclesBits;\r
+ }\r
+ */\r
+}\r
+\r
+}}\r
--- /dev/null
+// Compress/RangeCoder/RangeCoderBit.h\r
+\r
+#ifndef __COMPRESS_RANGECODER_BIT_H\r
+#define __COMPRESS_RANGECODER_BIT_H\r
+\r
+#include "RangeCoder.h"\r
+\r
+namespace NCompress {\r
+namespace NRangeCoder {\r
+\r
+const int kNumBitModelTotalBits = 11;\r
+const UInt32 kBitModelTotal = (1 << kNumBitModelTotalBits);\r
+\r
+const int kNumMoveReducingBits = 2;\r
+\r
+const int kNumBitPriceShiftBits = 6;\r
+const UInt32 kBitPrice = 1 << kNumBitPriceShiftBits;\r
+\r
+class CPriceTables\r
+{\r
+public:\r
+ static UInt32 ProbPrices[kBitModelTotal >> kNumMoveReducingBits];\r
+ static void Init();\r
+ CPriceTables();\r
+};\r
+\r
+template <int numMoveBits>\r
+class CBitModel\r
+{\r
+public:\r
+ UInt32 Prob;\r
+ void UpdateModel(UInt32 symbol)\r
+ {\r
+ /*\r
+ Prob -= (Prob + ((symbol - 1) & ((1 << numMoveBits) - 1))) >> numMoveBits;\r
+ Prob += (1 - symbol) << (kNumBitModelTotalBits - numMoveBits);\r
+ */\r
+ if (symbol == 0)\r
+ Prob += (kBitModelTotal - Prob) >> numMoveBits;\r
+ else\r
+ Prob -= (Prob) >> numMoveBits;\r
+ }\r
+public:\r
+ void Init() { Prob = kBitModelTotal / 2; }\r
+};\r
+\r
+template <int numMoveBits>\r
+class CBitEncoder: public CBitModel<numMoveBits>\r
+{\r
+public:\r
+ void Encode(CEncoder *encoder, UInt32 symbol)\r
+ {\r
+ /*\r
+ encoder->EncodeBit(this->Prob, kNumBitModelTotalBits, symbol);\r
+ this->UpdateModel(symbol);\r
+ */\r
+ UInt32 newBound = (encoder->Range >> kNumBitModelTotalBits) * this->Prob;\r
+ if (symbol == 0)\r
+ {\r
+ encoder->Range = newBound;\r
+ this->Prob += (kBitModelTotal - this->Prob) >> numMoveBits;\r
+ }\r
+ else\r
+ {\r
+ encoder->Low += newBound;\r
+ encoder->Range -= newBound;\r
+ this->Prob -= (this->Prob) >> numMoveBits;\r
+ }\r
+ if (encoder->Range < kTopValue)\r
+ {\r
+ encoder->Range <<= 8;\r
+ encoder->ShiftLow();\r
+ }\r
+ }\r
+ UInt32 GetPrice(UInt32 symbol) const\r
+ {\r
+ return CPriceTables::ProbPrices[\r
+ (((this->Prob - symbol) ^ ((-(int)symbol))) & (kBitModelTotal - 1)) >> kNumMoveReducingBits];\r
+ }\r
+ UInt32 GetPrice0() const { return CPriceTables::ProbPrices[this->Prob >> kNumMoveReducingBits]; }\r
+ UInt32 GetPrice1() const { return CPriceTables::ProbPrices[(kBitModelTotal - this->Prob) >> kNumMoveReducingBits]; }\r
+};\r
+\r
+\r
+template <int numMoveBits>\r
+class CBitDecoder: public CBitModel<numMoveBits>\r
+{\r
+public:\r
+ UInt32 Decode(CDecoder *decoder)\r
+ {\r
+ UInt32 newBound = (decoder->Range >> kNumBitModelTotalBits) * this->Prob;\r
+ if (decoder->Code < newBound)\r
+ {\r
+ decoder->Range = newBound;\r
+ this->Prob += (kBitModelTotal - this->Prob) >> numMoveBits;\r
+ if (decoder->Range < kTopValue)\r
+ {\r
+ decoder->Code = (decoder->Code << 8) | decoder->Stream.ReadByte();\r
+ decoder->Range <<= 8;\r
+ }\r
+ return 0;\r
+ }\r
+ else\r
+ {\r
+ decoder->Range -= newBound;\r
+ decoder->Code -= newBound;\r
+ this->Prob -= (this->Prob) >> numMoveBits;\r
+ if (decoder->Range < kTopValue)\r
+ {\r
+ decoder->Code = (decoder->Code << 8) | decoder->Stream.ReadByte();\r
+ decoder->Range <<= 8;\r
+ }\r
+ return 1;\r
+ }\r
+ }\r
+};\r
+\r
+}}\r
+\r
+#endif\r
--- /dev/null
+// Compress/RangeCoder/RangeCoderBitTree.h\r
+\r
+#ifndef __COMPRESS_RANGECODER_BIT_TREE_H\r
+#define __COMPRESS_RANGECODER_BIT_TREE_H\r
+\r
+#include "RangeCoderBit.h"\r
+#include "RangeCoderOpt.h"\r
+\r
+namespace NCompress {\r
+namespace NRangeCoder {\r
+\r
+template <int numMoveBits, int NumBitLevels>\r
+class CBitTreeEncoder\r
+{\r
+ CBitEncoder<numMoveBits> Models[1 << NumBitLevels];\r
+public:\r
+ void Init()\r
+ {\r
+ for(UInt32 i = 1; i < (1 << NumBitLevels); i++)\r
+ Models[i].Init();\r
+ }\r
+ void Encode(CEncoder *rangeEncoder, UInt32 symbol)\r
+ {\r
+ UInt32 modelIndex = 1;\r
+ for (int bitIndex = NumBitLevels; bitIndex != 0 ;)\r
+ {\r
+ bitIndex--;\r
+ UInt32 bit = (symbol >> bitIndex) & 1;\r
+ Models[modelIndex].Encode(rangeEncoder, bit);\r
+ modelIndex = (modelIndex << 1) | bit;\r
+ }\r
+ };\r
+ void ReverseEncode(CEncoder *rangeEncoder, UInt32 symbol)\r
+ {\r
+ UInt32 modelIndex = 1;\r
+ for (int i = 0; i < NumBitLevels; i++)\r
+ {\r
+ UInt32 bit = symbol & 1;\r
+ Models[modelIndex].Encode(rangeEncoder, bit);\r
+ modelIndex = (modelIndex << 1) | bit;\r
+ symbol >>= 1;\r
+ }\r
+ }\r
+ UInt32 GetPrice(UInt32 symbol) const\r
+ {\r
+ symbol |= (1 << NumBitLevels);\r
+ UInt32 price = 0;\r
+ while (symbol != 1)\r
+ {\r
+ price += Models[symbol >> 1].GetPrice(symbol & 1);\r
+ symbol >>= 1;\r
+ }\r
+ return price;\r
+ }\r
+ UInt32 ReverseGetPrice(UInt32 symbol) const\r
+ {\r
+ UInt32 price = 0;\r
+ UInt32 modelIndex = 1;\r
+ for (int i = NumBitLevels; i != 0; i--)\r
+ {\r
+ UInt32 bit = symbol & 1;\r
+ symbol >>= 1;\r
+ price += Models[modelIndex].GetPrice(bit);\r
+ modelIndex = (modelIndex << 1) | bit;\r
+ }\r
+ return price;\r
+ }\r
+};\r
+\r
+template <int numMoveBits, int NumBitLevels>\r
+class CBitTreeDecoder\r
+{\r
+ CBitDecoder<numMoveBits> Models[1 << NumBitLevels];\r
+public:\r
+ void Init()\r
+ {\r
+ for(UInt32 i = 1; i < (1 << NumBitLevels); i++)\r
+ Models[i].Init();\r
+ }\r
+ UInt32 Decode(CDecoder *rangeDecoder)\r
+ {\r
+ UInt32 modelIndex = 1;\r
+ RC_INIT_VAR\r
+ for(int bitIndex = NumBitLevels; bitIndex != 0; bitIndex--)\r
+ {\r
+ // modelIndex = (modelIndex << 1) + Models[modelIndex].Decode(rangeDecoder);\r
+ RC_GETBIT(numMoveBits, Models[modelIndex].Prob, modelIndex)\r
+ }\r
+ RC_FLUSH_VAR\r
+ return modelIndex - (1 << NumBitLevels);\r
+ };\r
+ UInt32 ReverseDecode(CDecoder *rangeDecoder)\r
+ {\r
+ UInt32 modelIndex = 1;\r
+ UInt32 symbol = 0;\r
+ RC_INIT_VAR\r
+ for(int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)\r
+ {\r
+ // UInt32 bit = Models[modelIndex].Decode(rangeDecoder);\r
+ // modelIndex <<= 1;\r
+ // modelIndex += bit;\r
+ // symbol |= (bit << bitIndex);\r
+ RC_GETBIT2(numMoveBits, Models[modelIndex].Prob, modelIndex, ; , symbol |= (1 << bitIndex))\r
+ }\r
+ RC_FLUSH_VAR\r
+ return symbol;\r
+ }\r
+};\r
+\r
+template <int numMoveBits>\r
+void ReverseBitTreeEncode(CBitEncoder<numMoveBits> *Models, \r
+ CEncoder *rangeEncoder, int NumBitLevels, UInt32 symbol)\r
+{\r
+ UInt32 modelIndex = 1;\r
+ for (int i = 0; i < NumBitLevels; i++)\r
+ {\r
+ UInt32 bit = symbol & 1;\r
+ Models[modelIndex].Encode(rangeEncoder, bit);\r
+ modelIndex = (modelIndex << 1) | bit;\r
+ symbol >>= 1;\r
+ }\r
+}\r
+\r
+template <int numMoveBits>\r
+UInt32 ReverseBitTreeGetPrice(CBitEncoder<numMoveBits> *Models, \r
+ UInt32 NumBitLevels, UInt32 symbol)\r
+{\r
+ UInt32 price = 0;\r
+ UInt32 modelIndex = 1;\r
+ for (int i = NumBitLevels; i != 0; i--)\r
+ {\r
+ UInt32 bit = symbol & 1;\r
+ symbol >>= 1;\r
+ price += Models[modelIndex].GetPrice(bit);\r
+ modelIndex = (modelIndex << 1) | bit;\r
+ }\r
+ return price;\r
+}\r
+\r
+template <int numMoveBits>\r
+UInt32 ReverseBitTreeDecode(CBitDecoder<numMoveBits> *Models, \r
+ CDecoder *rangeDecoder, int NumBitLevels)\r
+{\r
+ UInt32 modelIndex = 1;\r
+ UInt32 symbol = 0;\r
+ RC_INIT_VAR\r
+ for(int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)\r
+ {\r
+ // UInt32 bit = Models[modelIndex].Decode(rangeDecoder);\r
+ // modelIndex <<= 1;\r
+ // modelIndex += bit;\r
+ // symbol |= (bit << bitIndex);\r
+ RC_GETBIT2(numMoveBits, Models[modelIndex].Prob, modelIndex, ; , symbol |= (1 << bitIndex))\r
+ }\r
+ RC_FLUSH_VAR\r
+ return symbol;\r
+}\r
+\r
+}}\r
+\r
+#endif\r
--- /dev/null
+// Compress/RangeCoder/RangeCoderOpt.h\r
+\r
+#ifndef __COMPRESS_RANGECODER_OPT_H\r
+#define __COMPRESS_RANGECODER_OPT_H\r
+\r
+#define RC_INIT_VAR \\r
+ UInt32 range = rangeDecoder->Range; \\r
+ UInt32 code = rangeDecoder->Code; \r
+\r
+#define RC_FLUSH_VAR \\r
+ rangeDecoder->Range = range; \\r
+ rangeDecoder->Code = code;\r
+\r
+#define RC_NORMALIZE \\r
+ if (range < NCompress::NRangeCoder::kTopValue) \\r
+ { code = (code << 8) | rangeDecoder->Stream.ReadByte(); range <<= 8; }\r
+\r
+#define RC_GETBIT2(numMoveBits, prob, mi, A0, A1) \\r
+ { UInt32 bound = (range >> NCompress::NRangeCoder::kNumBitModelTotalBits) * prob; \\r
+ if (code < bound) \\r
+ { A0; range = bound; \\r
+ prob += (NCompress::NRangeCoder::kBitModelTotal - prob) >> numMoveBits; \\r
+ mi <<= 1; } \\r
+ else \\r
+ { A1; range -= bound; code -= bound; prob -= (prob) >> numMoveBits; \\r
+ mi = (mi + mi) + 1; }} \\r
+ RC_NORMALIZE\r
+\r
+#define RC_GETBIT(numMoveBits, prob, mi) RC_GETBIT2(numMoveBits, prob, mi, ; , ;)\r
+\r
+#endif\r
--- /dev/null
+// StdAfx.h\r
+\r
+#ifndef __STDAFX_H\r
+#define __STDAFX_H\r
+\r
+#endif\r
--- /dev/null
+/*
+ LzmaDecode.c
+ LZMA Decoder (optimized for Speed version)
+
+ LZMA SDK 4.22 Copyright (c) 1999-2005 Igor Pavlov (2005-06-10)
+ http://www.7-zip.org/
+
+ LZMA SDK is licensed under two licenses:
+ 1) GNU Lesser General Public License (GNU LGPL)
+ 2) Common Public License (CPL)
+ It means that you can select one of these two licenses and
+ follow rules of that license.
+
+ SPECIAL EXCEPTION:
+ Igor Pavlov, as the author of this Code, expressly permits you to
+ statically or dynamically link your Code (or bind by name) to the
+ interfaces of this file without subjecting your linked Code to the
+ terms of the CPL or GNU LGPL. Any modifications or additions
+ to this file, however, are subject to the LGPL or CPL terms.
+*/
+
+#include "LzmaDecode.h"
+
+#ifndef Byte
+#define Byte unsigned char
+#endif
+
+#define kNumTopBits 24
+#define kTopValue ((UInt32)1 << kNumTopBits)
+
+#define kNumBitModelTotalBits 11
+#define kBitModelTotal (1 << kNumBitModelTotalBits)
+#define kNumMoveBits 5
+
+#define RC_READ_BYTE (*Buffer++)
+
+#define RC_INIT2 Code = 0; Range = 0xFFFFFFFF; \
+ { int i; for(i = 0; i < 5; i++) { RC_TEST; Code = (Code << 8) | RC_READ_BYTE; }}
+
+#ifdef _LZMA_IN_CB
+
+#define RC_TEST { if (Buffer == BufferLim) \
+ { SizeT size; int result = InCallback->Read(InCallback, &Buffer, &size); if (result != LZMA_RESULT_OK) return result; \
+ BufferLim = Buffer + size; if (size == 0) return LZMA_RESULT_DATA_ERROR; }}
+
+#define RC_INIT Buffer = BufferLim = 0; RC_INIT2
+
+#else
+
+#define RC_TEST { if (Buffer == BufferLim) return LZMA_RESULT_DATA_ERROR; }
+
+#define RC_INIT(buffer, bufferSize) Buffer = buffer; BufferLim = buffer + bufferSize; RC_INIT2
+
+#endif
+
+#define RC_NORMALIZE if (Range < kTopValue) { RC_TEST; Range <<= 8; Code = (Code << 8) | RC_READ_BYTE; }
+
+#define IfBit0(p) RC_NORMALIZE; bound = (Range >> kNumBitModelTotalBits) * *(p); if (Code < bound)
+#define UpdateBit0(p) Range = bound; *(p) += (kBitModelTotal - *(p)) >> kNumMoveBits;
+#define UpdateBit1(p) Range -= bound; Code -= bound; *(p) -= (*(p)) >> kNumMoveBits;
+
+#define RC_GET_BIT2(p, mi, A0, A1) IfBit0(p) \
+ { UpdateBit0(p); mi <<= 1; A0; } else \
+ { UpdateBit1(p); mi = (mi + mi) + 1; A1; }
+
+#define RC_GET_BIT(p, mi) RC_GET_BIT2(p, mi, ; , ;)
+
+#define RangeDecoderBitTreeDecode(probs, numLevels, res) \
+ { int i = numLevels; res = 1; \
+ do { CProb *p = probs + res; RC_GET_BIT(p, res) } while(--i != 0); \
+ res -= (1 << numLevels); }
+
+
+#define kNumPosBitsMax 4
+#define kNumPosStatesMax (1 << kNumPosBitsMax)
+
+#define kLenNumLowBits 3
+#define kLenNumLowSymbols (1 << kLenNumLowBits)
+#define kLenNumMidBits 3
+#define kLenNumMidSymbols (1 << kLenNumMidBits)
+#define kLenNumHighBits 8
+#define kLenNumHighSymbols (1 << kLenNumHighBits)
+
+#define LenChoice 0
+#define LenChoice2 (LenChoice + 1)
+#define LenLow (LenChoice2 + 1)
+#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits))
+#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits))
+#define kNumLenProbs (LenHigh + kLenNumHighSymbols)
+
+
+#define kNumStates 12
+#define kNumLitStates 7
+
+#define kStartPosModelIndex 4
+#define kEndPosModelIndex 14
+#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
+
+#define kNumPosSlotBits 6
+#define kNumLenToPosStates 4
+
+#define kNumAlignBits 4
+#define kAlignTableSize (1 << kNumAlignBits)
+
+#define kMatchMinLen 2
+
+#define IsMatch 0
+#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax))
+#define IsRepG0 (IsRep + kNumStates)
+#define IsRepG1 (IsRepG0 + kNumStates)
+#define IsRepG2 (IsRepG1 + kNumStates)
+#define IsRep0Long (IsRepG2 + kNumStates)
+#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax))
+#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))
+#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex)
+#define LenCoder (Align + kAlignTableSize)
+#define RepLenCoder (LenCoder + kNumLenProbs)
+#define Literal (RepLenCoder + kNumLenProbs)
+
+#if Literal != LZMA_BASE_SIZE
+StopCompilingDueBUG
+#endif
+
+int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size)
+{
+ unsigned char prop0;
+ if (size < LZMA_PROPERTIES_SIZE)
+ return LZMA_RESULT_DATA_ERROR;
+ prop0 = propsData[0];
+ if (prop0 >= (9 * 5 * 5))
+ return LZMA_RESULT_DATA_ERROR;
+ {
+ for (propsRes->pb = 0; prop0 >= (9 * 5); propsRes->pb++, prop0 -= (9 * 5));
+ for (propsRes->lp = 0; prop0 >= 9; propsRes->lp++, prop0 -= 9);
+ propsRes->lc = prop0;
+ /*
+ unsigned char remainder = (unsigned char)(prop0 / 9);
+ propsRes->lc = prop0 % 9;
+ propsRes->pb = remainder / 5;
+ propsRes->lp = remainder % 5;
+ */
+ }
+
+ #ifdef _LZMA_OUT_READ
+ {
+ int i;
+ propsRes->DictionarySize = 0;
+ for (i = 0; i < 4; i++)
+ propsRes->DictionarySize += (UInt32)(propsData[1 + i]) << (i * 8);
+ if (propsRes->DictionarySize == 0)
+ propsRes->DictionarySize = 1;
+ }
+ #endif
+ return LZMA_RESULT_OK;
+}
+
+#define kLzmaStreamWasFinishedId (-1)
+
+int LzmaDecode(CLzmaDecoderState *vs,
+ #ifdef _LZMA_IN_CB
+ ILzmaInCallback *InCallback,
+ #else
+ const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed,
+ #endif
+ unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed)
+{
+ CProb *p = vs->Probs;
+ SizeT nowPos = 0;
+ Byte previousByte = 0;
+ UInt32 posStateMask = (1 << (vs->Properties.pb)) - 1;
+ UInt32 literalPosMask = (1 << (vs->Properties.lp)) - 1;
+ int lc = vs->Properties.lc;
+
+ #ifdef _LZMA_OUT_READ
+
+ UInt32 Range = vs->Range;
+ UInt32 Code = vs->Code;
+ #ifdef _LZMA_IN_CB
+ const Byte *Buffer = vs->Buffer;
+ const Byte *BufferLim = vs->BufferLim;
+ #else
+ const Byte *Buffer = inStream;
+ const Byte *BufferLim = inStream + inSize;
+ #endif
+ int state = vs->State;
+ UInt32 rep0 = vs->Reps[0], rep1 = vs->Reps[1], rep2 = vs->Reps[2], rep3 = vs->Reps[3];
+ int len = vs->RemainLen;
+ UInt32 globalPos = vs->GlobalPos;
+ UInt32 distanceLimit = vs->DistanceLimit;
+
+ Byte *dictionary = vs->Dictionary;
+ UInt32 dictionarySize = vs->Properties.DictionarySize;
+ UInt32 dictionaryPos = vs->DictionaryPos;
+
+ Byte tempDictionary[4];
+
+ #ifndef _LZMA_IN_CB
+ *inSizeProcessed = 0;
+ #endif
+ *outSizeProcessed = 0;
+ if (len == kLzmaStreamWasFinishedId)
+ return LZMA_RESULT_OK;
+
+ if (dictionarySize == 0)
+ {
+ dictionary = tempDictionary;
+ dictionarySize = 1;
+ tempDictionary[0] = vs->TempDictionary[0];
+ }
+
+ if (len == kLzmaNeedInitId)
+ {
+ {
+ UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp));
+ UInt32 i;
+ for (i = 0; i < numProbs; i++)
+ p[i] = kBitModelTotal >> 1;
+ rep0 = rep1 = rep2 = rep3 = 1;
+ state = 0;
+ globalPos = 0;
+ distanceLimit = 0;
+ dictionaryPos = 0;
+ dictionary[dictionarySize - 1] = 0;
+ #ifdef _LZMA_IN_CB
+ RC_INIT;
+ #else
+ RC_INIT(inStream, inSize);
+ #endif
+ }
+ len = 0;
+ }
+ while(len != 0 && nowPos < outSize)
+ {
+ UInt32 pos = dictionaryPos - rep0;
+ if (pos >= dictionarySize)
+ pos += dictionarySize;
+ outStream[nowPos++] = dictionary[dictionaryPos] = dictionary[pos];
+ if (++dictionaryPos == dictionarySize)
+ dictionaryPos = 0;
+ len--;
+ }
+ if (dictionaryPos == 0)
+ previousByte = dictionary[dictionarySize - 1];
+ else
+ previousByte = dictionary[dictionaryPos - 1];
+
+ #else /* if !_LZMA_OUT_READ */
+
+ int state = 0;
+ UInt32 rep0 = 1, rep1 = 1, rep2 = 1, rep3 = 1;
+ int len = 0;
+ const Byte *Buffer;
+ const Byte *BufferLim;
+ UInt32 Range;
+ UInt32 Code;
+
+ #ifndef _LZMA_IN_CB
+ *inSizeProcessed = 0;
+ #endif
+ *outSizeProcessed = 0;
+
+ {
+ UInt32 i;
+ UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp));
+ for (i = 0; i < numProbs; i++)
+ p[i] = kBitModelTotal >> 1;
+ }
+
+ #ifdef _LZMA_IN_CB
+ RC_INIT;
+ #else
+ RC_INIT(inStream, inSize);
+ #endif
+
+ #endif /* _LZMA_OUT_READ */
+
+ while(nowPos < outSize)
+ {
+ CProb *prob;
+ UInt32 bound;
+ int posState = (int)(
+ (nowPos
+ #ifdef _LZMA_OUT_READ
+ + globalPos
+ #endif
+ )
+ & posStateMask);
+
+ prob = p + IsMatch + (state << kNumPosBitsMax) + posState;
+ IfBit0(prob)
+ {
+ int symbol = 1;
+ UpdateBit0(prob)
+ prob = p + Literal + (LZMA_LIT_SIZE *
+ (((
+ (nowPos
+ #ifdef _LZMA_OUT_READ
+ + globalPos
+ #endif
+ )
+ & literalPosMask) << lc) + (previousByte >> (8 - lc))));
+
+ if (state >= kNumLitStates)
+ {
+ int matchByte;
+ #ifdef _LZMA_OUT_READ
+ UInt32 pos = dictionaryPos - rep0;
+ if (pos >= dictionarySize)
+ pos += dictionarySize;
+ matchByte = dictionary[pos];
+ #else
+ matchByte = outStream[nowPos - rep0];
+ #endif
+ do
+ {
+ int bit;
+ CProb *probLit;
+ matchByte <<= 1;
+ bit = (matchByte & 0x100);
+ probLit = prob + 0x100 + bit + symbol;
+ RC_GET_BIT2(probLit, symbol, if (bit != 0) break, if (bit == 0) break)
+ }
+ while (symbol < 0x100);
+ }
+ while (symbol < 0x100)
+ {
+ CProb *probLit = prob + symbol;
+ RC_GET_BIT(probLit, symbol)
+ }
+ previousByte = (Byte)symbol;
+
+ outStream[nowPos++] = previousByte;
+ #ifdef _LZMA_OUT_READ
+ if (distanceLimit < dictionarySize)
+ distanceLimit++;
+
+ dictionary[dictionaryPos] = previousByte;
+ if (++dictionaryPos == dictionarySize)
+ dictionaryPos = 0;
+ #endif
+ if (state < 4) state = 0;
+ else if (state < 10) state -= 3;
+ else state -= 6;
+ }
+ else
+ {
+ UpdateBit1(prob);
+ prob = p + IsRep + state;
+ IfBit0(prob)
+ {
+ UpdateBit0(prob);
+ rep3 = rep2;
+ rep2 = rep1;
+ rep1 = rep0;
+ state = state < kNumLitStates ? 0 : 3;
+ prob = p + LenCoder;
+ }
+ else
+ {
+ UpdateBit1(prob);
+ prob = p + IsRepG0 + state;
+ IfBit0(prob)
+ {
+ UpdateBit0(prob);
+ prob = p + IsRep0Long + (state << kNumPosBitsMax) + posState;
+ IfBit0(prob)
+ {
+ #ifdef _LZMA_OUT_READ
+ UInt32 pos;
+ #endif
+ UpdateBit0(prob);
+
+ #ifdef _LZMA_OUT_READ
+ if (distanceLimit == 0)
+ #else
+ if (nowPos == 0)
+ #endif
+ return LZMA_RESULT_DATA_ERROR;
+
+ state = state < kNumLitStates ? 9 : 11;
+ #ifdef _LZMA_OUT_READ
+ pos = dictionaryPos - rep0;
+ if (pos >= dictionarySize)
+ pos += dictionarySize;
+ previousByte = dictionary[pos];
+ dictionary[dictionaryPos] = previousByte;
+ if (++dictionaryPos == dictionarySize)
+ dictionaryPos = 0;
+ #else
+ previousByte = outStream[nowPos - rep0];
+ #endif
+ outStream[nowPos++] = previousByte;
+ #ifdef _LZMA_OUT_READ
+ if (distanceLimit < dictionarySize)
+ distanceLimit++;
+ #endif
+
+ continue;
+ }
+ else
+ {
+ UpdateBit1(prob);
+ }
+ }
+ else
+ {
+ UInt32 distance;
+ UpdateBit1(prob);
+ prob = p + IsRepG1 + state;
+ IfBit0(prob)
+ {
+ UpdateBit0(prob);
+ distance = rep1;
+ }
+ else
+ {
+ UpdateBit1(prob);
+ prob = p + IsRepG2 + state;
+ IfBit0(prob)
+ {
+ UpdateBit0(prob);
+ distance = rep2;
+ }
+ else
+ {
+ UpdateBit1(prob);
+ distance = rep3;
+ rep3 = rep2;
+ }
+ rep2 = rep1;
+ }
+ rep1 = rep0;
+ rep0 = distance;
+ }
+ state = state < kNumLitStates ? 8 : 11;
+ prob = p + RepLenCoder;
+ }
+ {
+ int numBits, offset;
+ CProb *probLen = prob + LenChoice;
+ IfBit0(probLen)
+ {
+ UpdateBit0(probLen);
+ probLen = prob + LenLow + (posState << kLenNumLowBits);
+ offset = 0;
+ numBits = kLenNumLowBits;
+ }
+ else
+ {
+ UpdateBit1(probLen);
+ probLen = prob + LenChoice2;
+ IfBit0(probLen)
+ {
+ UpdateBit0(probLen);
+ probLen = prob + LenMid + (posState << kLenNumMidBits);
+ offset = kLenNumLowSymbols;
+ numBits = kLenNumMidBits;
+ }
+ else
+ {
+ UpdateBit1(probLen);
+ probLen = prob + LenHigh;
+ offset = kLenNumLowSymbols + kLenNumMidSymbols;
+ numBits = kLenNumHighBits;
+ }
+ }
+ RangeDecoderBitTreeDecode(probLen, numBits, len);
+ len += offset;
+ }
+
+ if (state < 4)
+ {
+ int posSlot;
+ state += kNumLitStates;
+ prob = p + PosSlot +
+ ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) <<
+ kNumPosSlotBits);
+ RangeDecoderBitTreeDecode(prob, kNumPosSlotBits, posSlot);
+ if (posSlot >= kStartPosModelIndex)
+ {
+ int numDirectBits = ((posSlot >> 1) - 1);
+ rep0 = (2 | ((UInt32)posSlot & 1));
+ if (posSlot < kEndPosModelIndex)
+ {
+ rep0 <<= numDirectBits;
+ prob = p + SpecPos + rep0 - posSlot - 1;
+ }
+ else
+ {
+ numDirectBits -= kNumAlignBits;
+ do
+ {
+ RC_NORMALIZE
+ Range >>= 1;
+ rep0 <<= 1;
+ if (Code >= Range)
+ {
+ Code -= Range;
+ rep0 |= 1;
+ }
+ }
+ while (--numDirectBits != 0);
+ prob = p + Align;
+ rep0 <<= kNumAlignBits;
+ numDirectBits = kNumAlignBits;
+ }
+ {
+ int i = 1;
+ int mi = 1;
+ do
+ {
+ CProb *prob3 = prob + mi;
+ RC_GET_BIT2(prob3, mi, ; , rep0 |= i);
+ i <<= 1;
+ }
+ while(--numDirectBits != 0);
+ }
+ }
+ else
+ rep0 = posSlot;
+ if (++rep0 == (UInt32)(0))
+ {
+ /* it's for stream version */
+ len = kLzmaStreamWasFinishedId;
+ break;
+ }
+ }
+
+ len += kMatchMinLen;
+ #ifdef _LZMA_OUT_READ
+ if (rep0 > distanceLimit)
+ #else
+ if (rep0 > nowPos)
+ #endif
+ return LZMA_RESULT_DATA_ERROR;
+
+ #ifdef _LZMA_OUT_READ
+ if (dictionarySize - distanceLimit > (UInt32)len)
+ distanceLimit += len;
+ else
+ distanceLimit = dictionarySize;
+ #endif
+
+ do
+ {
+ #ifdef _LZMA_OUT_READ
+ UInt32 pos = dictionaryPos - rep0;
+ if (pos >= dictionarySize)
+ pos += dictionarySize;
+ previousByte = dictionary[pos];
+ dictionary[dictionaryPos] = previousByte;
+ if (++dictionaryPos == dictionarySize)
+ dictionaryPos = 0;
+ #else
+ previousByte = outStream[nowPos - rep0];
+ #endif
+ len--;
+ outStream[nowPos++] = previousByte;
+ }
+ while(len != 0 && nowPos < outSize);
+ }
+ }
+ RC_NORMALIZE;
+
+ #ifdef _LZMA_OUT_READ
+ vs->Range = Range;
+ vs->Code = Code;
+ vs->DictionaryPos = dictionaryPos;
+ vs->GlobalPos = globalPos + (UInt32)nowPos;
+ vs->DistanceLimit = distanceLimit;
+ vs->Reps[0] = rep0;
+ vs->Reps[1] = rep1;
+ vs->Reps[2] = rep2;
+ vs->Reps[3] = rep3;
+ vs->State = state;
+ vs->RemainLen = len;
+ vs->TempDictionary[0] = tempDictionary[0];
+ #endif
+
+ #ifdef _LZMA_IN_CB
+ vs->Buffer = Buffer;
+ vs->BufferLim = BufferLim;
+ #else
+ *inSizeProcessed = (SizeT)(Buffer - inStream);
+ #endif
+ *outSizeProcessed = nowPos;
+ return LZMA_RESULT_OK;
+}
--- /dev/null
+/*
+ LzmaDecode.h
+ LZMA Decoder interface
+
+ LZMA SDK 4.21 Copyright (c) 1999-2005 Igor Pavlov (2005-06-08)
+ http://www.7-zip.org/
+
+ LZMA SDK is licensed under two licenses:
+ 1) GNU Lesser General Public License (GNU LGPL)
+ 2) Common Public License (CPL)
+ It means that you can select one of these two licenses and
+ follow rules of that license.
+
+ SPECIAL EXCEPTION:
+ Igor Pavlov, as the author of this code, expressly permits you to
+ statically or dynamically link your code (or bind by name) to the
+ interfaces of this file without subjecting your linked code to the
+ terms of the CPL or GNU LGPL. Any modifications or additions
+ to this file, however, are subject to the LGPL or CPL terms.
+*/
+
+#ifndef __LZMADECODE_H
+#define __LZMADECODE_H
+
+/* #define _LZMA_IN_CB */
+/* Use callback for input data */
+
+/* #define _LZMA_OUT_READ */
+/* Use read function for output data */
+
+/* #define _LZMA_PROB32 */
+/* It can increase speed on some 32-bit CPUs,
+ but memory usage will be doubled in that case */
+
+/* #define _LZMA_LOC_OPT */
+/* Enable local speed optimizations inside code */
+
+/* #define _LZMA_SYSTEM_SIZE_T */
+/* Use system's size_t. You can use it to enable 64-bit sizes supporting*/
+
+#ifndef UInt32
+#ifdef _LZMA_UINT32_IS_ULONG
+#define UInt32 unsigned long
+#else
+#define UInt32 unsigned int
+#endif
+#endif
+
+#ifndef SizeT
+#ifdef _LZMA_SYSTEM_SIZE_T
+#include <stddef.h>
+#define SizeT size_t
+#else
+#define SizeT UInt32
+#endif
+#endif
+
+#ifdef _LZMA_PROB32
+#define CProb UInt32
+#else
+#define CProb unsigned short
+#endif
+
+#define LZMA_RESULT_OK 0
+#define LZMA_RESULT_DATA_ERROR 1
+
+#ifdef _LZMA_IN_CB
+typedef struct _ILzmaInCallback
+{
+ int (*Read)(void *object, const unsigned char **buffer, SizeT *bufferSize);
+} ILzmaInCallback;
+#endif
+
+#define LZMA_BASE_SIZE 1846
+#define LZMA_LIT_SIZE 768
+
+#define LZMA_PROPERTIES_SIZE 5
+
+typedef struct _CLzmaProperties
+{
+ int lc;
+ int lp;
+ int pb;
+ #ifdef _LZMA_OUT_READ
+ UInt32 DictionarySize;
+ #endif
+}CLzmaProperties;
+
+int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size);
+
+#define LzmaGetNumProbs(Properties) (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((Properties)->lc + (Properties)->lp)))
+
+#define kLzmaNeedInitId (-2)
+
+typedef struct _CLzmaDecoderState
+{
+ CLzmaProperties Properties;
+ CProb *Probs;
+
+ #ifdef _LZMA_IN_CB
+ const unsigned char *Buffer;
+ const unsigned char *BufferLim;
+ #endif
+
+ #ifdef _LZMA_OUT_READ
+ unsigned char *Dictionary;
+ UInt32 Range;
+ UInt32 Code;
+ UInt32 DictionaryPos;
+ UInt32 GlobalPos;
+ UInt32 DistanceLimit;
+ UInt32 Reps[4];
+ int State;
+ int RemainLen;
+ unsigned char TempDictionary[4];
+ #endif
+} CLzmaDecoderState;
+
+#ifdef _LZMA_OUT_READ
+#define LzmaDecoderInit(vs) { (vs)->RemainLen = kLzmaNeedInitId; }
+#endif
+
+int LzmaDecode(CLzmaDecoderState *vs,
+ #ifdef _LZMA_IN_CB
+ ILzmaInCallback *inCallback,
+ #else
+ const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed,
+ #endif
+ unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed);
+
+#endif
--- /dev/null
+// ICoder.h\r
+\r
+#ifndef __ICODER_H\r
+#define __ICODER_H\r
+\r
+#include "IStream.h"\r
+\r
+// "23170F69-40C1-278A-0000-000400xx0000"\r
+#define CODER_INTERFACE(i, x) \\r
+DEFINE_GUID(IID_ ## i, \\r
+0x23170F69, 0x40C1, 0x278A, 0x00, 0x00, 0x00, 0x04, 0x00, x, 0x00, 0x00); \\r
+struct i: public IUnknown\r
+\r
+CODER_INTERFACE(ICompressProgressInfo, 0x04)\r
+{\r
+ STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize) PURE;\r
+};\r
+\r
+CODER_INTERFACE(ICompressCoder, 0x05)\r
+{\r
+ STDMETHOD(Code)(ISequentialInStream *inStream,\r
+ ISequentialOutStream *outStream, \r
+ const UInt64 *inSize, \r
+ const UInt64 *outSize,\r
+ ICompressProgressInfo *progress) PURE;\r
+};\r
+\r
+CODER_INTERFACE(ICompressCoder2, 0x18)\r
+{\r
+ STDMETHOD(Code)(ISequentialInStream **inStreams,\r
+ const UInt64 **inSizes, \r
+ UInt32 numInStreams,\r
+ ISequentialOutStream **outStreams, \r
+ const UInt64 **outSizes,\r
+ UInt32 numOutStreams,\r
+ ICompressProgressInfo *progress) PURE;\r
+};\r
+\r
+namespace NCoderPropID\r
+{\r
+ enum EEnum\r
+ {\r
+ kDictionarySize = 0x400,\r
+ kUsedMemorySize,\r
+ kOrder,\r
+ kPosStateBits = 0x440,\r
+ kLitContextBits,\r
+ kLitPosBits,\r
+ kNumFastBytes = 0x450,\r
+ kMatchFinder,\r
+ kMatchFinderCycles,\r
+ kNumPasses = 0x460, \r
+ kAlgorithm = 0x470,\r
+ kMultiThread = 0x480,\r
+ kNumThreads,\r
+ kEndMarker = 0x490\r
+ };\r
+}\r
+\r
+CODER_INTERFACE(ICompressSetCoderProperties, 0x20)\r
+{\r
+ STDMETHOD(SetCoderProperties)(const PROPID *propIDs, \r
+ const PROPVARIANT *properties, UInt32 numProperties) PURE;\r
+};\r
+\r
+/*\r
+CODER_INTERFACE(ICompressSetCoderProperties, 0x21)\r
+{\r
+ STDMETHOD(SetDecoderProperties)(ISequentialInStream *inStream) PURE;\r
+};\r
+*/\r
+\r
+CODER_INTERFACE(ICompressSetDecoderProperties2, 0x22)\r
+{\r
+ STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size) PURE;\r
+};\r
+\r
+CODER_INTERFACE(ICompressWriteCoderProperties, 0x23)\r
+{\r
+ STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStreams) PURE;\r
+};\r
+\r
+CODER_INTERFACE(ICompressGetInStreamProcessedSize, 0x24)\r
+{\r
+ STDMETHOD(GetInStreamProcessedSize)(UInt64 *value) PURE;\r
+};\r
+\r
+CODER_INTERFACE(ICompressSetCoderMt, 0x25)\r
+{\r
+ STDMETHOD(SetNumberOfThreads)(UInt32 numThreads) PURE;\r
+};\r
+\r
+CODER_INTERFACE(ICompressGetSubStreamSize, 0x30)\r
+{\r
+ STDMETHOD(GetSubStreamSize)(UInt64 subStream, UInt64 *value) PURE;\r
+};\r
+\r
+CODER_INTERFACE(ICompressSetInStream, 0x31)\r
+{\r
+ STDMETHOD(SetInStream)(ISequentialInStream *inStream) PURE;\r
+ STDMETHOD(ReleaseInStream)() PURE;\r
+};\r
+\r
+CODER_INTERFACE(ICompressSetOutStream, 0x32)\r
+{\r
+ STDMETHOD(SetOutStream)(ISequentialOutStream *outStream) PURE;\r
+ STDMETHOD(ReleaseOutStream)() PURE;\r
+};\r
+\r
+CODER_INTERFACE(ICompressSetInStreamSize, 0x33)\r
+{\r
+ STDMETHOD(SetInStreamSize)(const UInt64 *inSize) PURE;\r
+};\r
+\r
+CODER_INTERFACE(ICompressSetOutStreamSize, 0x34)\r
+{\r
+ STDMETHOD(SetOutStreamSize)(const UInt64 *outSize) PURE;\r
+};\r
+\r
+CODER_INTERFACE(ICompressFilter, 0x40)\r
+{\r
+ STDMETHOD(Init)() PURE;\r
+ STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size) PURE;\r
+ // Filter return outSize (UInt32)\r
+ // if (outSize <= size): Filter have converted outSize bytes\r
+ // if (outSize > size): Filter have not converted anything.\r
+ // and it needs at least outSize bytes to convert one block \r
+ // (it's for crypto block algorithms).\r
+};\r
+\r
+CODER_INTERFACE(ICryptoProperties, 0x80)\r
+{\r
+ STDMETHOD(SetKey)(const Byte *data, UInt32 size) PURE;\r
+ STDMETHOD(SetInitVector)(const Byte *data, UInt32 size) PURE;\r
+};\r
+\r
+CODER_INTERFACE(ICryptoSetPassword, 0x90)\r
+{\r
+ STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size) PURE;\r
+};\r
+\r
+CODER_INTERFACE(ICryptoSetCRC, 0xA0)\r
+{\r
+ STDMETHOD(CryptoSetCRC)(UInt32 crc) PURE;\r
+};\r
+\r
+//////////////////////\r
+// It's for DLL file\r
+namespace NMethodPropID\r
+{\r
+ enum EEnum\r
+ {\r
+ kID,\r
+ kName,\r
+ kDecoder,\r
+ kEncoder,\r
+ kInStreams,\r
+ kOutStreams,\r
+ kDescription\r
+ };\r
+}\r
+\r
+#endif\r
--- /dev/null
+// IStream.h\r
+\r
+#ifndef __ISTREAM_H\r
+#define __ISTREAM_H\r
+\r
+#include "../Common/MyUnknown.h"\r
+#include "../Common/Types.h"\r
+\r
+// "23170F69-40C1-278A-0000-000300xx0000"\r
+\r
+#define STREAM_INTERFACE_SUB(i, b, x) \\r
+DEFINE_GUID(IID_ ## i, \\r
+0x23170F69, 0x40C1, 0x278A, 0x00, 0x00, 0x00, 0x03, 0x00, x, 0x00, 0x00); \\r
+struct i: public b\r
+\r
+#define STREAM_INTERFACE(i, x) STREAM_INTERFACE_SUB(i, IUnknown, x)\r
+\r
+STREAM_INTERFACE(ISequentialInStream, 0x01)\r
+{\r
+ STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize) PURE;\r
+ /*\r
+ Out: if size != 0, return_value = S_OK and (*processedSize == 0),\r
+ then there are no more bytes in stream.\r
+ if (size > 0) && there are bytes in stream, \r
+ this function must read at least 1 byte.\r
+ This function is allowed to read less than number of remaining bytes in stream.\r
+ You must call Read function in loop, if you need exact amount of data\r
+ */\r
+};\r
+\r
+STREAM_INTERFACE(ISequentialOutStream, 0x02)\r
+{\r
+ STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize) PURE;\r
+ /*\r
+ if (size > 0) this function must write at least 1 byte.\r
+ This function is allowed to write less than "size".\r
+ You must call Write function in loop, if you need to write exact amount of data\r
+ */\r
+};\r
+\r
+STREAM_INTERFACE_SUB(IInStream, ISequentialInStream, 0x03)\r
+{\r
+ STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) PURE;\r
+};\r
+\r
+STREAM_INTERFACE_SUB(IOutStream, ISequentialOutStream, 0x04)\r
+{\r
+ STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) PURE;\r
+ STDMETHOD(SetSize)(Int64 newSize) PURE;\r
+};\r
+\r
+STREAM_INTERFACE(IStreamGetSize, 0x06)\r
+{\r
+ STDMETHOD(GetSize)(UInt64 *size) PURE;\r
+};\r
+\r
+STREAM_INTERFACE(IOutStreamFlush, 0x07)\r
+{\r
+ STDMETHOD(Flush)() PURE;\r
+};\r
+\r
+#endif\r
--- /dev/null
+// Common/Alloc.cpp\r
+\r
+#include "StdAfx.h"\r
+\r
+#ifdef _WIN32\r
+#include "MyWindows.h"\r
+#else\r
+#include <stdlib.h>\r
+#endif\r
+\r
+#include "Alloc.h"\r
+\r
+/* #define _SZ_ALLOC_DEBUG */\r
+/* use _SZ_ALLOC_DEBUG to debug alloc/free operations */\r
+#ifdef _SZ_ALLOC_DEBUG\r
+#include <stdio.h>\r
+int g_allocCount = 0;\r
+int g_allocCountMid = 0;\r
+int g_allocCountBig = 0;\r
+#endif\r
+\r
+void *MyAlloc(size_t size) throw()\r
+{\r
+ if (size == 0)\r
+ return 0;\r
+ #ifdef _SZ_ALLOC_DEBUG\r
+ fprintf(stderr, "\nAlloc %10d bytes; count = %10d", size, g_allocCount++);\r
+ #endif\r
+ return ::malloc(size);\r
+}\r
+\r
+void MyFree(void *address) throw()\r
+{\r
+ #ifdef _SZ_ALLOC_DEBUG\r
+ if (address != 0)\r
+ fprintf(stderr, "\nFree; count = %10d", --g_allocCount);\r
+ #endif\r
+ \r
+ ::free(address);\r
+}\r
+\r
+#ifdef _WIN32\r
+\r
+void *MidAlloc(size_t size) throw()\r
+{\r
+ if (size == 0)\r
+ return 0;\r
+ #ifdef _SZ_ALLOC_DEBUG\r
+ fprintf(stderr, "\nAlloc_Mid %10d bytes; count = %10d", size, g_allocCountMid++);\r
+ #endif\r
+ return ::VirtualAlloc(0, size, MEM_COMMIT, PAGE_READWRITE);\r
+}\r
+\r
+void MidFree(void *address) throw()\r
+{\r
+ #ifdef _SZ_ALLOC_DEBUG\r
+ if (address != 0)\r
+ fprintf(stderr, "\nFree_Mid; count = %10d", --g_allocCountMid);\r
+ #endif\r
+ if (address == 0)\r
+ return;\r
+ ::VirtualFree(address, 0, MEM_RELEASE);\r
+}\r
+\r
+static SIZE_T g_LargePageSize = \r
+ #ifdef _WIN64\r
+ (1 << 21);\r
+ #else\r
+ (1 << 22);\r
+ #endif\r
+\r
+typedef SIZE_T (WINAPI *GetLargePageMinimumP)();\r
+\r
+bool SetLargePageSize()\r
+{\r
+ GetLargePageMinimumP largePageMinimum = (GetLargePageMinimumP)\r
+ ::GetProcAddress(::GetModuleHandle(TEXT("kernel32.dll")), "GetLargePageMinimum");\r
+ if (largePageMinimum == 0)\r
+ return false;\r
+ SIZE_T size = largePageMinimum();\r
+ if (size == 0 || (size & (size - 1)) != 0)\r
+ return false;\r
+ g_LargePageSize = size;\r
+ return true;\r
+}\r
+\r
+\r
+void *BigAlloc(size_t size) throw()\r
+{\r
+ if (size == 0)\r
+ return 0;\r
+ #ifdef _SZ_ALLOC_DEBUG\r
+ fprintf(stderr, "\nAlloc_Big %10d bytes; count = %10d", size, g_allocCountBig++);\r
+ #endif\r
+ \r
+ if (size >= (1 << 18))\r
+ {\r
+ void *res = ::VirtualAlloc(0, (size + g_LargePageSize - 1) & (~(g_LargePageSize - 1)), \r
+ MEM_COMMIT | MEM_LARGE_PAGES, PAGE_READWRITE);\r
+ if (res != 0)\r
+ return res;\r
+ }\r
+ return ::VirtualAlloc(0, size, MEM_COMMIT, PAGE_READWRITE);\r
+}\r
+\r
+void BigFree(void *address) throw()\r
+{\r
+ #ifdef _SZ_ALLOC_DEBUG\r
+ if (address != 0)\r
+ fprintf(stderr, "\nFree_Big; count = %10d", --g_allocCountBig);\r
+ #endif\r
+ \r
+ if (address == 0)\r
+ return;\r
+ ::VirtualFree(address, 0, MEM_RELEASE);\r
+}\r
+\r
+#endif\r
--- /dev/null
+// Common/Alloc.h\r
+\r
+#ifndef __COMMON_ALLOC_H\r
+#define __COMMON_ALLOC_H\r
+\r
+#include <stddef.h>\r
+\r
+void *MyAlloc(size_t size) throw();\r
+void MyFree(void *address) throw();\r
+\r
+#ifdef _WIN32\r
+\r
+bool SetLargePageSize();\r
+\r
+void *MidAlloc(size_t size) throw();\r
+void MidFree(void *address) throw();\r
+void *BigAlloc(size_t size) throw();\r
+void BigFree(void *address) throw();\r
+\r
+#else\r
+\r
+#define MidAlloc(size) MyAlloc(size)\r
+#define MidFree(address) MyFree(address)\r
+#define BigAlloc(size) MyAlloc(size)\r
+#define BigFree(address) MyFree(address)\r
+\r
+#endif\r
+\r
+#endif\r
--- /dev/null
+// Common/CRC.cpp\r
+\r
+#include "StdAfx.h"\r
+\r
+#include "CRC.h"\r
+\r
+static const UInt32 kCRCPoly = 0xEDB88320;\r
+\r
+UInt32 CCRC::Table[256];\r
+\r
+void CCRC::InitTable()\r
+{\r
+ for (UInt32 i = 0; i < 256; i++)\r
+ {\r
+ UInt32 r = i;\r
+ for (int j = 0; j < 8; j++)\r
+ if (r & 1) \r
+ r = (r >> 1) ^ kCRCPoly;\r
+ else \r
+ r >>= 1;\r
+ CCRC::Table[i] = r;\r
+ }\r
+}\r
+\r
+class CCRCTableInit\r
+{\r
+public:\r
+ CCRCTableInit() { CCRC::InitTable(); }\r
+} g_CRCTableInit;\r
+\r
+void CCRC::UpdateByte(Byte b)\r
+{\r
+ _value = Table[((Byte)(_value)) ^ b] ^ (_value >> 8);\r
+}\r
+\r
+void CCRC::UpdateUInt16(UInt16 v)\r
+{\r
+ UpdateByte(Byte(v));\r
+ UpdateByte(Byte(v >> 8));\r
+}\r
+\r
+void CCRC::UpdateUInt32(UInt32 v)\r
+{\r
+ for (int i = 0; i < 4; i++)\r
+ UpdateByte((Byte)(v >> (8 * i)));\r
+}\r
+\r
+void CCRC::UpdateUInt64(UInt64 v)\r
+{\r
+ for (int i = 0; i < 8; i++)\r
+ UpdateByte((Byte)(v >> (8 * i)));\r
+}\r
+\r
+void CCRC::Update(const void *data, size_t size)\r
+{\r
+ UInt32 v = _value;\r
+ const Byte *p = (const Byte *)data;\r
+ for (; size > 0 ; size--, p++)\r
+ v = Table[((Byte)(v)) ^ *p] ^ (v >> 8);\r
+ _value = v;\r
+}\r
--- /dev/null
+// Common/CRC.h\r
+\r
+#ifndef __COMMON_CRC_H\r
+#define __COMMON_CRC_H\r
+\r
+#include <stddef.h>\r
+#include "Types.h"\r
+\r
+class CCRC\r
+{\r
+ UInt32 _value;\r
+public:\r
+ static UInt32 Table[256];\r
+ static void InitTable();\r
+\r
+ CCRC(): _value(0xFFFFFFFF){};\r
+ void Init() { _value = 0xFFFFFFFF; }\r
+ void UpdateByte(Byte v);\r
+ void UpdateUInt16(UInt16 v);\r
+ void UpdateUInt32(UInt32 v);\r
+ void UpdateUInt64(UInt64 v);\r
+ void Update(const void *data, size_t size);\r
+ UInt32 GetDigest() const { return _value ^ 0xFFFFFFFF; } \r
+ static UInt32 CalculateDigest(const void *data, size_t size)\r
+ {\r
+ CCRC crc;\r
+ crc.Update(data, size);\r
+ return crc.GetDigest();\r
+ }\r
+ static bool VerifyDigest(UInt32 digest, const void *data, size_t size)\r
+ {\r
+ return (CalculateDigest(data, size) == digest);\r
+ }\r
+};\r
+\r
+#endif\r
--- /dev/null
+// Common/Defs.h\r
+\r
+#ifndef __COMMON_DEFS_H\r
+#define __COMMON_DEFS_H\r
+\r
+template <class T> inline T MyMin(T a, T b)\r
+ { return a < b ? a : b; }\r
+template <class T> inline T MyMax(T a, T b)\r
+ { return a > b ? a : b; }\r
+\r
+template <class T> inline int MyCompare(T a, T b)\r
+ { return a < b ? -1 : (a == b ? 0 : 1); }\r
+\r
+inline int BoolToInt(bool value)\r
+ { return (value ? 1: 0); }\r
+\r
+inline bool IntToBool(int value)\r
+ { return (value != 0); }\r
+\r
+#endif\r
--- /dev/null
+// MyCom.h\r
+\r
+#ifndef __MYCOM_H\r
+#define __MYCOM_H\r
+\r
+#include "MyWindows.h"\r
+\r
+#define RINOK(x) { HRESULT __result_ = (x); if(__result_ != S_OK) return __result_; }\r
+\r
+template <class T>\r
+class CMyComPtr\r
+{\r
+ T* _p;\r
+public:\r
+ // typedef T _PtrClass;\r
+ CMyComPtr() { _p = NULL;}\r
+ CMyComPtr(T* p) {if ((_p = p) != NULL) p->AddRef(); }\r
+ CMyComPtr(const CMyComPtr<T>& lp)\r
+ {\r
+ if ((_p = lp._p) != NULL)\r
+ _p->AddRef();\r
+ }\r
+ ~CMyComPtr() { if (_p) _p->Release(); }\r
+ void Release() { if (_p) { _p->Release(); _p = NULL; } }\r
+ operator T*() const { return (T*)_p; }\r
+ // T& operator*() const { return *_p; }\r
+ T** operator&() { return &_p; }\r
+ T* operator->() const { return _p; }\r
+ T* operator=(T* p) \r
+ { \r
+ if (p != 0)\r
+ p->AddRef();\r
+ if (_p) \r
+ _p->Release();\r
+ _p = p;\r
+ return p;\r
+ }\r
+ T* operator=(const CMyComPtr<T>& lp) { return (*this = lp._p); }\r
+ bool operator!() const { return (_p == NULL); }\r
+ // bool operator==(T* pT) const { return _p == pT; }\r
+ // Compare two objects for equivalence\r
+ void Attach(T* p2)\r
+ {\r
+ Release();\r
+ _p = p2;\r
+ }\r
+ T* Detach()\r
+ {\r
+ T* pt = _p;\r
+ _p = NULL;\r
+ return pt;\r
+ }\r
+ #ifdef _WIN32\r
+ HRESULT CoCreateInstance(REFCLSID rclsid, REFIID iid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)\r
+ {\r
+ return ::CoCreateInstance(rclsid, pUnkOuter, dwClsContext, iid, (void**)&_p);\r
+ }\r
+ #endif\r
+ /*\r
+ HRESULT CoCreateInstance(LPCOLESTR szProgID, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)\r
+ {\r
+ CLSID clsid;\r
+ HRESULT hr = CLSIDFromProgID(szProgID, &clsid);\r
+ ATLASSERT(_p == NULL);\r
+ if (SUCCEEDED(hr))\r
+ hr = ::CoCreateInstance(clsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&_p);\r
+ return hr;\r
+ }\r
+ */\r
+ template <class Q>\r
+ HRESULT QueryInterface(REFGUID iid, Q** pp) const\r
+ {\r
+ return _p->QueryInterface(iid, (void**)pp);\r
+ }\r
+};\r
+\r
+//////////////////////////////////////////////////////////\r
+\r
+class CMyComBSTR\r
+{\r
+public:\r
+ BSTR m_str;\r
+ CMyComBSTR() { m_str = NULL; }\r
+ CMyComBSTR(LPCOLESTR pSrc) { m_str = ::SysAllocString(pSrc); }\r
+ // CMyComBSTR(int nSize) { m_str = ::SysAllocStringLen(NULL, nSize); }\r
+ // CMyComBSTR(int nSize, LPCOLESTR sz) { m_str = ::SysAllocStringLen(sz, nSize); }\r
+ CMyComBSTR(const CMyComBSTR& src) { m_str = src.MyCopy(); }\r
+ /*\r
+ CMyComBSTR(REFGUID src)\r
+ {\r
+ LPOLESTR szGuid;\r
+ StringFromCLSID(src, &szGuid);\r
+ m_str = ::SysAllocString(szGuid);\r
+ CoTaskMemFree(szGuid);\r
+ }\r
+ */\r
+ ~CMyComBSTR() { ::SysFreeString(m_str); }\r
+ CMyComBSTR& operator=(const CMyComBSTR& src)\r
+ {\r
+ if (m_str != src.m_str)\r
+ {\r
+ if (m_str)\r
+ ::SysFreeString(m_str);\r
+ m_str = src.MyCopy();\r
+ }\r
+ return *this;\r
+ }\r
+ CMyComBSTR& operator=(LPCOLESTR pSrc)\r
+ {\r
+ ::SysFreeString(m_str);\r
+ m_str = ::SysAllocString(pSrc);\r
+ return *this;\r
+ }\r
+ unsigned int Length() const { return ::SysStringLen(m_str); }\r
+ operator BSTR() const { return m_str; }\r
+ BSTR* operator&() { return &m_str; }\r
+ BSTR MyCopy() const \r
+ { \r
+ int byteLen = ::SysStringByteLen(m_str);\r
+ BSTR res = ::SysAllocStringByteLen(NULL, byteLen);\r
+ memmove(res, m_str, byteLen);\r
+ return res;\r
+ }\r
+ void Attach(BSTR src) { m_str = src; }\r
+ BSTR Detach()\r
+ {\r
+ BSTR s = m_str;\r
+ m_str = NULL;\r
+ return s;\r
+ }\r
+ void Empty()\r
+ {\r
+ ::SysFreeString(m_str);\r
+ m_str = NULL;\r
+ }\r
+ bool operator!() const { return (m_str == NULL); }\r
+};\r
+\r
+\r
+//////////////////////////////////////////////////////////\r
+\r
+class CMyUnknownImp\r
+{\r
+public:\r
+ ULONG __m_RefCount;\r
+ CMyUnknownImp(): __m_RefCount(0) {}\r
+};\r
+\r
+#define MY_QUERYINTERFACE_BEGIN STDMETHOD(QueryInterface) \\r
+ (REFGUID iid, void **outObject) { \r
+\r
+#define MY_QUERYINTERFACE_ENTRY(i) if (iid == IID_ ## i) \\r
+ { *outObject = (void *)(i *)this; AddRef(); return S_OK; }\r
+\r
+#define MY_QUERYINTERFACE_END return E_NOINTERFACE; }\r
+\r
+#define MY_ADDREF_RELEASE \\r
+STDMETHOD_(ULONG, AddRef)() { return ++__m_RefCount; } \\r
+STDMETHOD_(ULONG, Release)() { if (--__m_RefCount != 0) \\r
+ return __m_RefCount; delete this; return 0; }\r
+\r
+#define MY_UNKNOWN_IMP_SPEC(i) \\r
+ MY_QUERYINTERFACE_BEGIN \\r
+ i \\r
+ MY_QUERYINTERFACE_END \\r
+ MY_ADDREF_RELEASE\r
+\r
+\r
+#define MY_UNKNOWN_IMP STDMETHOD(QueryInterface)(REFGUID, void **) { \\r
+ MY_QUERYINTERFACE_END \\r
+ MY_ADDREF_RELEASE\r
+\r
+#define MY_UNKNOWN_IMP1(i) MY_UNKNOWN_IMP_SPEC( \\r
+ MY_QUERYINTERFACE_ENTRY(i) \\r
+ )\r
+\r
+#define MY_UNKNOWN_IMP2(i1, i2) MY_UNKNOWN_IMP_SPEC( \\r
+ MY_QUERYINTERFACE_ENTRY(i1) \\r
+ MY_QUERYINTERFACE_ENTRY(i2) \\r
+ )\r
+\r
+#define MY_UNKNOWN_IMP3(i1, i2, i3) MY_UNKNOWN_IMP_SPEC( \\r
+ MY_QUERYINTERFACE_ENTRY(i1) \\r
+ MY_QUERYINTERFACE_ENTRY(i2) \\r
+ MY_QUERYINTERFACE_ENTRY(i3) \\r
+ )\r
+\r
+#define MY_UNKNOWN_IMP4(i1, i2, i3, i4) MY_UNKNOWN_IMP_SPEC( \\r
+ MY_QUERYINTERFACE_ENTRY(i1) \\r
+ MY_QUERYINTERFACE_ENTRY(i2) \\r
+ MY_QUERYINTERFACE_ENTRY(i3) \\r
+ MY_QUERYINTERFACE_ENTRY(i4) \\r
+ )\r
+\r
+#define MY_UNKNOWN_IMP5(i1, i2, i3, i4, i5) MY_UNKNOWN_IMP_SPEC( \\r
+ MY_QUERYINTERFACE_ENTRY(i1) \\r
+ MY_QUERYINTERFACE_ENTRY(i2) \\r
+ MY_QUERYINTERFACE_ENTRY(i3) \\r
+ MY_QUERYINTERFACE_ENTRY(i4) \\r
+ MY_QUERYINTERFACE_ENTRY(i5) \\r
+ )\r
+\r
+#endif\r
--- /dev/null
+// Common/MyGuidDef.h\r
+\r
+#ifndef GUID_DEFINED\r
+#define GUID_DEFINED\r
+\r
+#include "Types.h"\r
+\r
+typedef struct {\r
+ UInt32 Data1;\r
+ UInt16 Data2;\r
+ UInt16 Data3;\r
+ unsigned char Data4[8];\r
+} GUID;\r
+\r
+#ifdef __cplusplus\r
+#define REFGUID const GUID &\r
+#else\r
+#define REFGUID const GUID *\r
+#endif\r
+\r
+#define REFCLSID REFGUID\r
+#define REFIID REFGUID\r
+\r
+#ifdef __cplusplus\r
+inline bool operator==(REFGUID g1, REFGUID g2)\r
+{ \r
+ for (int i = 0; i < (int)sizeof(g1); i++)\r
+ if (((const unsigned char *)&g1)[i] != ((const unsigned char *)&g2)[i])\r
+ return false;\r
+ return true;\r
+}\r
+inline bool operator!=(REFGUID g1, REFGUID g2) { return !(g1 == g2); }\r
+#endif\r
+\r
+#ifdef __cplusplus\r
+ #define MY_EXTERN_C extern "C"\r
+#else\r
+ #define MY_EXTERN_C extern\r
+#endif\r
+\r
+#endif // GUID_DEFINED\r
+\r
+\r
+#ifdef DEFINE_GUID\r
+#undef DEFINE_GUID\r
+#endif\r
+\r
+#ifdef INITGUID\r
+ #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \\r
+ MY_EXTERN_C const GUID name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }\r
+#else\r
+ #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \\r
+ MY_EXTERN_C const GUID name\r
+#endif\r
--- /dev/null
+// Common/MyInitGuid.h\r
+\r
+#ifndef __COMMON_MYINITGUID_H\r
+#define __COMMON_MYINITGUID_H\r
+\r
+#ifdef _WIN32\r
+#include <initguid.h>\r
+#else\r
+#define INITGUID\r
+#include "MyGuidDef.h"\r
+#endif\r
+\r
+#endif\r
--- /dev/null
+// MyUnknown.h\r
+\r
+#ifndef __MYUNKNOWN_H\r
+#define __MYUNKNOWN_H\r
+\r
+#ifdef _WIN32\r
+\r
+#ifdef _WIN32_WCE\r
+#if (_WIN32_WCE > 300)\r
+#include <basetyps.h>\r
+#else\r
+#define MIDL_INTERFACE(x) struct \r
+#endif\r
+#else\r
+#include <basetyps.h>\r
+#endif\r
+\r
+#include <unknwn.h>\r
+\r
+#else \r
+#include "MyWindows.h"\r
+#endif\r
+ \r
+#endif\r
--- /dev/null
+// MyWindows.h\r
+\r
+#ifndef __MYWINDOWS_H\r
+#define __MYWINDOWS_H\r
+\r
+#ifdef _WIN32\r
+\r
+#include <windows.h>\r
+\r
+#define CHAR_PATH_SEPARATOR '\\'\r
+#define WCHAR_PATH_SEPARATOR L'\\'\r
+#define STRING_PATH_SEPARATOR "\\"\r
+#define WSTRING_PATH_SEPARATOR L"\\"\r
+\r
+#else\r
+\r
+#define CHAR_PATH_SEPARATOR '/'\r
+#define WCHAR_PATH_SEPARATOR L'/'\r
+#define STRING_PATH_SEPARATOR "/"\r
+#define WSTRING_PATH_SEPARATOR L"/"\r
+\r
+#include <stddef.h> // for wchar_t\r
+#include <string.h>\r
+\r
+#include "MyGuidDef.h"\r
+\r
+typedef char CHAR;\r
+typedef unsigned char UCHAR;\r
+\r
+#undef BYTE\r
+typedef unsigned char BYTE;\r
+\r
+typedef short SHORT;\r
+typedef unsigned short USHORT;\r
+\r
+#undef WORD\r
+typedef unsigned short WORD;\r
+typedef short VARIANT_BOOL;\r
+\r
+typedef int INT;\r
+typedef Int32 INT32;\r
+typedef unsigned int UINT;\r
+typedef UInt32 UINT32;\r
+typedef INT32 LONG; // LONG, ULONG and DWORD must be 32-bit\r
+typedef UINT32 ULONG;\r
+\r
+#undef DWORD\r
+typedef UINT32 DWORD;\r
+\r
+typedef Int64 LONGLONG;\r
+typedef UInt64 ULONGLONG;\r
+\r
+typedef struct LARGE_INTEGER { LONGLONG QuadPart; }LARGE_INTEGER;\r
+typedef struct _ULARGE_INTEGER { ULONGLONG QuadPart;} ULARGE_INTEGER;\r
+\r
+typedef const CHAR *LPCSTR;\r
+typedef CHAR TCHAR;\r
+typedef const TCHAR *LPCTSTR;\r
+typedef wchar_t WCHAR;\r
+typedef WCHAR OLECHAR;\r
+typedef const WCHAR *LPCWSTR;\r
+typedef OLECHAR *BSTR;\r
+typedef const OLECHAR *LPCOLESTR;\r
+typedef OLECHAR *LPOLESTR;\r
+\r
+typedef struct _FILETIME\r
+{\r
+ DWORD dwLowDateTime;\r
+ DWORD dwHighDateTime;\r
+}FILETIME;\r
+\r
+#define HRESULT LONG\r
+#define FAILED(Status) ((HRESULT)(Status)<0)\r
+typedef ULONG PROPID;\r
+typedef LONG SCODE;\r
+\r
+#define S_OK ((HRESULT)0x00000000L)\r
+#define S_FALSE ((HRESULT)0x00000001L)\r
+#define E_NOTIMPL ((HRESULT)0x80004001L)\r
+#define E_NOINTERFACE ((HRESULT)0x80004002L)\r
+#define E_ABORT ((HRESULT)0x80004004L)\r
+#define E_FAIL ((HRESULT)0x80004005L)\r
+#define STG_E_INVALIDFUNCTION ((HRESULT)0x80030001L)\r
+#define E_OUTOFMEMORY ((HRESULT)0x8007000EL)\r
+#define E_INVALIDARG ((HRESULT)0x80070057L)\r
+\r
+#ifdef _MSC_VER\r
+#define STDMETHODCALLTYPE __stdcall \r
+#else\r
+#define STDMETHODCALLTYPE \r
+#endif\r
+\r
+#define STDMETHOD_(t, f) virtual t STDMETHODCALLTYPE f\r
+#define STDMETHOD(f) STDMETHOD_(HRESULT, f)\r
+#define STDMETHODIMP_(type) type STDMETHODCALLTYPE\r
+#define STDMETHODIMP STDMETHODIMP_(HRESULT)\r
+\r
+#define PURE = 0\r
+\r
+#define MIDL_INTERFACE(x) struct \r
+\r
+struct IUnknown\r
+{\r
+ //virtual ~IUnknown() {}\r
+ STDMETHOD(QueryInterface) (REFIID iid, void **outObject) PURE;\r
+ STDMETHOD_(ULONG, AddRef)() PURE;\r
+ STDMETHOD_(ULONG, Release)() PURE;\r
+};\r
+\r
+typedef IUnknown *LPUNKNOWN;\r
+\r
+#define VARIANT_TRUE ((VARIANT_BOOL)-1)\r
+#define VARIANT_FALSE ((VARIANT_BOOL)0)\r
+\r
+enum VARENUM\r
+{ \r
+ VT_EMPTY = 0,\r
+ VT_NULL = 1,\r
+ VT_I2 = 2,\r
+ VT_I4 = 3,\r
+ VT_R4 = 4,\r
+ VT_R8 = 5,\r
+ VT_CY = 6,\r
+ VT_DATE = 7,\r
+ VT_BSTR = 8,\r
+ VT_DISPATCH = 9,\r
+ VT_ERROR = 10,\r
+ VT_BOOL = 11,\r
+ VT_VARIANT = 12,\r
+ VT_UNKNOWN = 13,\r
+ VT_DECIMAL = 14,\r
+ VT_I1 = 16,\r
+ VT_UI1 = 17,\r
+ VT_UI2 = 18,\r
+ VT_UI4 = 19,\r
+ VT_I8 = 20,\r
+ VT_UI8 = 21,\r
+ VT_INT = 22,\r
+ VT_UINT = 23,\r
+ VT_VOID = 24,\r
+ VT_HRESULT = 25,\r
+ VT_FILETIME = 64\r
+};\r
+\r
+typedef unsigned short VARTYPE;\r
+typedef WORD PROPVAR_PAD1;\r
+typedef WORD PROPVAR_PAD2;\r
+typedef WORD PROPVAR_PAD3;\r
+\r
+typedef struct tagPROPVARIANT\r
+{\r
+ VARTYPE vt;\r
+ PROPVAR_PAD1 wReserved1;\r
+ PROPVAR_PAD2 wReserved2;\r
+ PROPVAR_PAD3 wReserved3;\r
+ union \r
+ {\r
+ CHAR cVal;\r
+ UCHAR bVal;\r
+ SHORT iVal;\r
+ USHORT uiVal;\r
+ LONG lVal;\r
+ ULONG ulVal;\r
+ INT intVal;\r
+ UINT uintVal;\r
+ LARGE_INTEGER hVal;\r
+ ULARGE_INTEGER uhVal;\r
+ VARIANT_BOOL boolVal;\r
+ SCODE scode;\r
+ FILETIME filetime;\r
+ BSTR bstrVal;\r
+ };\r
+} PROPVARIANT;\r
+\r
+typedef PROPVARIANT tagVARIANT;\r
+typedef tagVARIANT VARIANT;\r
+typedef VARIANT VARIANTARG;\r
+\r
+MY_EXTERN_C BSTR SysAllocStringByteLen(LPCSTR psz, UINT len);\r
+MY_EXTERN_C BSTR SysAllocString(const OLECHAR *sz);\r
+MY_EXTERN_C void SysFreeString(BSTR bstr);\r
+MY_EXTERN_C UINT SysStringByteLen(BSTR bstr);\r
+MY_EXTERN_C UINT SysStringLen(BSTR bstr);\r
+\r
+MY_EXTERN_C DWORD GetLastError();\r
+MY_EXTERN_C HRESULT VariantClear(VARIANTARG *prop);\r
+MY_EXTERN_C HRESULT VariantCopy(VARIANTARG *dest, VARIANTARG *src);\r
+MY_EXTERN_C LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2);\r
+\r
+#define CP_ACP 0\r
+#define CP_OEMCP 1\r
+\r
+typedef enum tagSTREAM_SEEK\r
+{ \r
+ STREAM_SEEK_SET = 0,\r
+ STREAM_SEEK_CUR = 1,\r
+ STREAM_SEEK_END = 2\r
+} STREAM_SEEK;\r
+\r
+#endif\r
+#endif\r
--- /dev/null
+// Common/NewHandler.h\r
+\r
+#ifndef __COMMON_NEWHANDLER_H\r
+#define __COMMON_NEWHANDLER_H\r
+\r
+class CNewException {};\r
+\r
+#ifdef _WIN32\r
+void \r
+#ifdef _MSC_VER\r
+__cdecl \r
+#endif\r
+operator delete(void *p) throw();\r
+#endif \r
+\r
+#endif \r
--- /dev/null
+// StdAfx.h\r
+\r
+#ifndef __STDAFX_H\r
+#define __STDAFX_H\r
+\r
+// #include "MyWindows.h"\r
+#include "NewHandler.h"\r
+\r
+#endif \r
--- /dev/null
+// Common/Types.h\r
+\r
+#ifndef __COMMON_TYPES_H\r
+#define __COMMON_TYPES_H\r
+\r
+typedef unsigned char Byte;\r
+typedef short Int16;\r
+typedef unsigned short UInt16;\r
+typedef int Int32;\r
+typedef unsigned int UInt32;\r
+#ifdef _MSC_VER\r
+typedef __int64 Int64;\r
+typedef unsigned __int64 UInt64;\r
+#else\r
+typedef long long int Int64;\r
+typedef unsigned long long int UInt64;\r
+#endif\r
+\r
+#endif\r
--- /dev/null
+ GNU LESSER GENERAL PUBLIC LICENSE\r
+ Version 2.1, February 1999\r
+\r
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.\r
+ 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r
+ Everyone is permitted to copy and distribute verbatim copies\r
+ of this license document, but changing it is not allowed.\r
+\r
+[This is the first released version of the Lesser GPL. It also counts\r
+ as the successor of the GNU Library Public License, version 2, hence\r
+ the version number 2.1.]\r
+\r
+ Preamble\r
+\r
+ The licenses for most software are designed to take away your\r
+freedom to share and change it. By contrast, the GNU General Public\r
+Licenses are intended to guarantee your freedom to share and change\r
+free software--to make sure the software is free for all its users.\r
+\r
+ This license, the Lesser General Public License, applies to some\r
+specially designated software packages--typically libraries--of the\r
+Free Software Foundation and other authors who decide to use it. You\r
+can use it too, but we suggest you first think carefully about whether\r
+this license or the ordinary General Public License is the better\r
+strategy to use in any particular case, based on the explanations below.\r
+\r
+ When we speak of free software, we are referring to freedom of use,\r
+not price. Our General Public Licenses are designed to make sure that\r
+you have the freedom to distribute copies of free software (and charge\r
+for this service if you wish); that you receive source code or can get\r
+it if you want it; that you can change the software and use pieces of\r
+it in new free programs; and that you are informed that you can do\r
+these things.\r
+\r
+ To protect your rights, we need to make restrictions that forbid\r
+distributors to deny you these rights or to ask you to surrender these\r
+rights. These restrictions translate to certain responsibilities for\r
+you if you distribute copies of the library or if you modify it.\r
+\r
+ For example, if you distribute copies of the library, whether gratis\r
+or for a fee, you must give the recipients all the rights that we gave\r
+you. You must make sure that they, too, receive or can get the source\r
+code. If you link other code with the library, you must provide\r
+complete object files to the recipients, so that they can relink them\r
+with the library after making changes to the library and recompiling\r
+it. And you must show them these terms so they know their rights.\r
+\r
+ We protect your rights with a two-step method: (1) we copyright the\r
+library, and (2) we offer you this license, which gives you legal\r
+permission to copy, distribute and/or modify the library.\r
+\r
+ To protect each distributor, we want to make it very clear that\r
+there is no warranty for the free library. Also, if the library is\r
+modified by someone else and passed on, the recipients should know\r
+that what they have is not the original version, so that the original\r
+author's reputation will not be affected by problems that might be\r
+introduced by others.\r
+\f\r
+ Finally, software patents pose a constant threat to the existence of\r
+any free program. We wish to make sure that a company cannot\r
+effectively restrict the users of a free program by obtaining a\r
+restrictive license from a patent holder. Therefore, we insist that\r
+any patent license obtained for a version of the library must be\r
+consistent with the full freedom of use specified in this license.\r
+\r
+ Most GNU software, including some libraries, is covered by the\r
+ordinary GNU General Public License. This license, the GNU Lesser\r
+General Public License, applies to certain designated libraries, and\r
+is quite different from the ordinary General Public License. We use\r
+this license for certain libraries in order to permit linking those\r
+libraries into non-free programs.\r
+\r
+ When a program is linked with a library, whether statically or using\r
+a shared library, the combination of the two is legally speaking a\r
+combined work, a derivative of the original library. The ordinary\r
+General Public License therefore permits such linking only if the\r
+entire combination fits its criteria of freedom. The Lesser General\r
+Public License permits more lax criteria for linking other code with\r
+the library.\r
+\r
+ We call this license the "Lesser" General Public License because it\r
+does Less to protect the user's freedom than the ordinary General\r
+Public License. It also provides other free software developers Less\r
+of an advantage over competing non-free programs. These disadvantages\r
+are the reason we use the ordinary General Public License for many\r
+libraries. However, the Lesser license provides advantages in certain\r
+special circumstances.\r
+\r
+ For example, on rare occasions, there may be a special need to\r
+encourage the widest possible use of a certain library, so that it becomes\r
+a de-facto standard. To achieve this, non-free programs must be\r
+allowed to use the library. A more frequent case is that a free\r
+library does the same job as widely used non-free libraries. In this\r
+case, there is little to gain by limiting the free library to free\r
+software only, so we use the Lesser General Public License.\r
+\r
+ In other cases, permission to use a particular library in non-free\r
+programs enables a greater number of people to use a large body of\r
+free software. For example, permission to use the GNU C Library in\r
+non-free programs enables many more people to use the whole GNU\r
+operating system, as well as its variant, the GNU/Linux operating\r
+system.\r
+\r
+ Although the Lesser General Public License is Less protective of the\r
+users' freedom, it does ensure that the user of a program that is\r
+linked with the Library has the freedom and the wherewithal to run\r
+that program using a modified version of the Library.\r
+\r
+ The precise terms and conditions for copying, distribution and\r
+modification follow. Pay close attention to the difference between a\r
+"work based on the library" and a "work that uses the library". The\r
+former contains code derived from the library, whereas the latter must\r
+be combined with the library in order to run.\r
+\f\r
+ GNU LESSER GENERAL PUBLIC LICENSE\r
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\r
+\r
+ 0. This License Agreement applies to any software library or other\r
+program which contains a notice placed by the copyright holder or\r
+other authorized party saying it may be distributed under the terms of\r
+this Lesser General Public License (also called "this License").\r
+Each licensee is addressed as "you".\r
+\r
+ A "library" means a collection of software functions and/or data\r
+prepared so as to be conveniently linked with application programs\r
+(which use some of those functions and data) to form executables.\r
+\r
+ The "Library", below, refers to any such software library or work\r
+which has been distributed under these terms. A "work based on the\r
+Library" means either the Library or any derivative work under\r
+copyright law: that is to say, a work containing the Library or a\r
+portion of it, either verbatim or with modifications and/or translated\r
+straightforwardly into another language. (Hereinafter, translation is\r
+included without limitation in the term "modification".)\r
+\r
+ "Source code" for a work means the preferred form of the work for\r
+making modifications to it. For a library, complete source code means\r
+all the source code for all modules it contains, plus any associated\r
+interface definition files, plus the scripts used to control compilation\r
+and installation of the library.\r
+\r
+ Activities other than copying, distribution and modification are not\r
+covered by this License; they are outside its scope. The act of\r
+running a program using the Library is not restricted, and output from\r
+such a program is covered only if its contents constitute a work based\r
+on the Library (independent of the use of the Library in a tool for\r
+writing it). Whether that is true depends on what the Library does\r
+and what the program that uses the Library does.\r
+ \r
+ 1. You may copy and distribute verbatim copies of the Library's\r
+complete source code as you receive it, in any medium, provided that\r
+you conspicuously and appropriately publish on each copy an\r
+appropriate copyright notice and disclaimer of warranty; keep intact\r
+all the notices that refer to this License and to the absence of any\r
+warranty; and distribute a copy of this License along with the\r
+Library.\r
+\r
+ You may charge a fee for the physical act of transferring a copy,\r
+and you may at your option offer warranty protection in exchange for a\r
+fee.\r
+\f\r
+ 2. You may modify your copy or copies of the Library or any portion\r
+of it, thus forming a work based on the Library, and copy and\r
+distribute such modifications or work under the terms of Section 1\r
+above, provided that you also meet all of these conditions:\r
+\r
+ a) The modified work must itself be a software library.\r
+\r
+ b) You must cause the files modified to carry prominent notices\r
+ stating that you changed the files and the date of any change.\r
+\r
+ c) You must cause the whole of the work to be licensed at no\r
+ charge to all third parties under the terms of this License.\r
+\r
+ d) If a facility in the modified Library refers to a function or a\r
+ table of data to be supplied by an application program that uses\r
+ the facility, other than as an argument passed when the facility\r
+ is invoked, then you must make a good faith effort to ensure that,\r
+ in the event an application does not supply such function or\r
+ table, the facility still operates, and performs whatever part of\r
+ its purpose remains meaningful.\r
+\r
+ (For example, a function in a library to compute square roots has\r
+ a purpose that is entirely well-defined independent of the\r
+ application. Therefore, Subsection 2d requires that any\r
+ application-supplied function or table used by this function must\r
+ be optional: if the application does not supply it, the square\r
+ root function must still compute square roots.)\r
+\r
+These requirements apply to the modified work as a whole. If\r
+identifiable sections of that work are not derived from the Library,\r
+and can be reasonably considered independent and separate works in\r
+themselves, then this License, and its terms, do not apply to those\r
+sections when you distribute them as separate works. But when you\r
+distribute the same sections as part of a whole which is a work based\r
+on the Library, the distribution of the whole must be on the terms of\r
+this License, whose permissions for other licensees extend to the\r
+entire whole, and thus to each and every part regardless of who wrote\r
+it.\r
+\r
+Thus, it is not the intent of this section to claim rights or contest\r
+your rights to work written entirely by you; rather, the intent is to\r
+exercise the right to control the distribution of derivative or\r
+collective works based on the Library.\r
+\r
+In addition, mere aggregation of another work not based on the Library\r
+with the Library (or with a work based on the Library) on a volume of\r
+a storage or distribution medium does not bring the other work under\r
+the scope of this License.\r
+\r
+ 3. You may opt to apply the terms of the ordinary GNU General Public\r
+License instead of this License to a given copy of the Library. To do\r
+this, you must alter all the notices that refer to this License, so\r
+that they refer to the ordinary GNU General Public License, version 2,\r
+instead of to this License. (If a newer version than version 2 of the\r
+ordinary GNU General Public License has appeared, then you can specify\r
+that version instead if you wish.) Do not make any other change in\r
+these notices.\r
+\f\r
+ Once this change is made in a given copy, it is irreversible for\r
+that copy, so the ordinary GNU General Public License applies to all\r
+subsequent copies and derivative works made from that copy.\r
+\r
+ This option is useful when you wish to copy part of the code of\r
+the Library into a program that is not a library.\r
+\r
+ 4. You may copy and distribute the Library (or a portion or\r
+derivative of it, under Section 2) in object code or executable form\r
+under the terms of Sections 1 and 2 above provided that you accompany\r
+it with the complete corresponding machine-readable source code, which\r
+must be distributed under the terms of Sections 1 and 2 above on a\r
+medium customarily used for software interchange.\r
+\r
+ If distribution of object code is made by offering access to copy\r
+from a designated place, then offering equivalent access to copy the\r
+source code from the same place satisfies the requirement to\r
+distribute the source code, even though third parties are not\r
+compelled to copy the source along with the object code.\r
+\r
+ 5. A program that contains no derivative of any portion of the\r
+Library, but is designed to work with the Library by being compiled or\r
+linked with it, is called a "work that uses the Library". Such a\r
+work, in isolation, is not a derivative work of the Library, and\r
+therefore falls outside the scope of this License.\r
+\r
+ However, linking a "work that uses the Library" with the Library\r
+creates an executable that is a derivative of the Library (because it\r
+contains portions of the Library), rather than a "work that uses the\r
+library". The executable is therefore covered by this License.\r
+Section 6 states terms for distribution of such executables.\r
+\r
+ When a "work that uses the Library" uses material from a header file\r
+that is part of the Library, the object code for the work may be a\r
+derivative work of the Library even though the source code is not.\r
+Whether this is true is especially significant if the work can be\r
+linked without the Library, or if the work is itself a library. The\r
+threshold for this to be true is not precisely defined by law.\r
+\r
+ If such an object file uses only numerical parameters, data\r
+structure layouts and accessors, and small macros and small inline\r
+functions (ten lines or less in length), then the use of the object\r
+file is unrestricted, regardless of whether it is legally a derivative\r
+work. (Executables containing this object code plus portions of the\r
+Library will still fall under Section 6.)\r
+\r
+ Otherwise, if the work is a derivative of the Library, you may\r
+distribute the object code for the work under the terms of Section 6.\r
+Any executables containing that work also fall under Section 6,\r
+whether or not they are linked directly with the Library itself.\r
+\f\r
+ 6. As an exception to the Sections above, you may also combine or\r
+link a "work that uses the Library" with the Library to produce a\r
+work containing portions of the Library, and distribute that work\r
+under terms of your choice, provided that the terms permit\r
+modification of the work for the customer's own use and reverse\r
+engineering for debugging such modifications.\r
+\r
+ You must give prominent notice with each copy of the work that the\r
+Library is used in it and that the Library and its use are covered by\r
+this License. You must supply a copy of this License. If the work\r
+during execution displays copyright notices, you must include the\r
+copyright notice for the Library among them, as well as a reference\r
+directing the user to the copy of this License. Also, you must do one\r
+of these things:\r
+\r
+ a) Accompany the work with the complete corresponding\r
+ machine-readable source code for the Library including whatever\r
+ changes were used in the work (which must be distributed under\r
+ Sections 1 and 2 above); and, if the work is an executable linked\r
+ with the Library, with the complete machine-readable "work that\r
+ uses the Library", as object code and/or source code, so that the\r
+ user can modify the Library and then relink to produce a modified\r
+ executable containing the modified Library. (It is understood\r
+ that the user who changes the contents of definitions files in the\r
+ Library will not necessarily be able to recompile the application\r
+ to use the modified definitions.)\r
+\r
+ b) Use a suitable shared library mechanism for linking with the\r
+ Library. A suitable mechanism is one that (1) uses at run time a\r
+ copy of the library already present on the user's computer system,\r
+ rather than copying library functions into the executable, and (2)\r
+ will operate properly with a modified version of the library, if\r
+ the user installs one, as long as the modified version is\r
+ interface-compatible with the version that the work was made with.\r
+\r
+ c) Accompany the work with a written offer, valid for at\r
+ least three years, to give the same user the materials\r
+ specified in Subsection 6a, above, for a charge no more\r
+ than the cost of performing this distribution.\r
+\r
+ d) If distribution of the work is made by offering access to copy\r
+ from a designated place, offer equivalent access to copy the above\r
+ specified materials from the same place.\r
+\r
+ e) Verify that the user has already received a copy of these\r
+ materials or that you have already sent this user a copy.\r
+\r
+ For an executable, the required form of the "work that uses the\r
+Library" must include any data and utility programs needed for\r
+reproducing the executable from it. However, as a special exception,\r
+the materials to be distributed need not include anything that is\r
+normally distributed (in either source or binary form) with the major\r
+components (compiler, kernel, and so on) of the operating system on\r
+which the executable runs, unless that component itself accompanies\r
+the executable.\r
+\r
+ It may happen that this requirement contradicts the license\r
+restrictions of other proprietary libraries that do not normally\r
+accompany the operating system. Such a contradiction means you cannot\r
+use both them and the Library together in an executable that you\r
+distribute.\r
+\f\r
+ 7. You may place library facilities that are a work based on the\r
+Library side-by-side in a single library together with other library\r
+facilities not covered by this License, and distribute such a combined\r
+library, provided that the separate distribution of the work based on\r
+the Library and of the other library facilities is otherwise\r
+permitted, and provided that you do these two things:\r
+\r
+ a) Accompany the combined library with a copy of the same work\r
+ based on the Library, uncombined with any other library\r
+ facilities. This must be distributed under the terms of the\r
+ Sections above.\r
+\r
+ b) Give prominent notice with the combined library of the fact\r
+ that part of it is a work based on the Library, and explaining\r
+ where to find the accompanying uncombined form of the same work.\r
+\r
+ 8. You may not copy, modify, sublicense, link with, or distribute\r
+the Library except as expressly provided under this License. Any\r
+attempt otherwise to copy, modify, sublicense, link with, or\r
+distribute the Library is void, and will automatically terminate your\r
+rights under this License. However, parties who have received copies,\r
+or rights, from you under this License will not have their licenses\r
+terminated so long as such parties remain in full compliance.\r
+\r
+ 9. You are not required to accept this License, since you have not\r
+signed it. However, nothing else grants you permission to modify or\r
+distribute the Library or its derivative works. These actions are\r
+prohibited by law if you do not accept this License. Therefore, by\r
+modifying or distributing the Library (or any work based on the\r
+Library), you indicate your acceptance of this License to do so, and\r
+all its terms and conditions for copying, distributing or modifying\r
+the Library or works based on it.\r
+\r
+ 10. Each time you redistribute the Library (or any work based on the\r
+Library), the recipient automatically receives a license from the\r
+original licensor to copy, distribute, link with or modify the Library\r
+subject to these terms and conditions. You may not impose any further\r
+restrictions on the recipients' exercise of the rights granted herein.\r
+You are not responsible for enforcing compliance by third parties with\r
+this License.\r
+\f\r
+ 11. If, as a consequence of a court judgment or allegation of patent\r
+infringement or for any other reason (not limited to patent issues),\r
+conditions are imposed on you (whether by court order, agreement or\r
+otherwise) that contradict the conditions of this License, they do not\r
+excuse you from the conditions of this License. If you cannot\r
+distribute so as to satisfy simultaneously your obligations under this\r
+License and any other pertinent obligations, then as a consequence you\r
+may not distribute the Library at all. For example, if a patent\r
+license would not permit royalty-free redistribution of the Library by\r
+all those who receive copies directly or indirectly through you, then\r
+the only way you could satisfy both it and this License would be to\r
+refrain entirely from distribution of the Library.\r
+\r
+If any portion of this section is held invalid or unenforceable under any\r
+particular circumstance, the balance of the section is intended to apply,\r
+and the section as a whole is intended to apply in other circumstances.\r
+\r
+It is not the purpose of this section to induce you to infringe any\r
+patents or other property right claims or to contest validity of any\r
+such claims; this section has the sole purpose of protecting the\r
+integrity of the free software distribution system which is\r
+implemented by public license practices. Many people have made\r
+generous contributions to the wide range of software distributed\r
+through that system in reliance on consistent application of that\r
+system; it is up to the author/donor to decide if he or she is willing\r
+to distribute software through any other system and a licensee cannot\r
+impose that choice.\r
+\r
+This section is intended to make thoroughly clear what is believed to\r
+be a consequence of the rest of this License.\r
+\r
+ 12. If the distribution and/or use of the Library is restricted in\r
+certain countries either by patents or by copyrighted interfaces, the\r
+original copyright holder who places the Library under this License may add\r
+an explicit geographical distribution limitation excluding those countries,\r
+so that distribution is permitted only in or among countries not thus\r
+excluded. In such case, this License incorporates the limitation as if\r
+written in the body of this License.\r
+\r
+ 13. The Free Software Foundation may publish revised and/or new\r
+versions of the Lesser General Public License from time to time.\r
+Such new versions will be similar in spirit to the present version,\r
+but may differ in detail to address new problems or concerns.\r
+\r
+Each version is given a distinguishing version number. If the Library\r
+specifies a version number of this License which applies to it and\r
+"any later version", you have the option of following the terms and\r
+conditions either of that version or of any later version published by\r
+the Free Software Foundation. If the Library does not specify a\r
+license version number, you may choose any version ever published by\r
+the Free Software Foundation.\r
+\f\r
+ 14. If you wish to incorporate parts of the Library into other free\r
+programs whose distribution conditions are incompatible with these,\r
+write to the author to ask for permission. For software which is\r
+copyrighted by the Free Software Foundation, write to the Free\r
+Software Foundation; we sometimes make exceptions for this. Our\r
+decision will be guided by the two goals of preserving the free status\r
+of all derivatives of our free software and of promoting the sharing\r
+and reuse of software generally.\r
+\r
+ NO WARRANTY\r
+\r
+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO\r
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.\r
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR\r
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY\r
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE\r
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE\r
+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME\r
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\r
+\r
+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN\r
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY\r
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU\r
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR\r
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE\r
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING\r
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A\r
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF\r
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH\r
+DAMAGES.\r
+\r
+ END OF TERMS AND CONDITIONS\r
+\f\r
+ How to Apply These Terms to Your New Libraries\r
+\r
+ If you develop a new library, and you want it to be of the greatest\r
+possible use to the public, we recommend making it free software that\r
+everyone can redistribute and change. You can do so by permitting\r
+redistribution under these terms (or, alternatively, under the terms of the\r
+ordinary General Public License).\r
+\r
+ To apply these terms, attach the following notices to the library. It is\r
+safest to attach them to the start of each source file to most effectively\r
+convey the exclusion of warranty; and each file should have at least the\r
+"copyright" line and a pointer to where the full notice is found.\r
+\r
+ <one line to give the library's name and a brief idea of what it does.>\r
+ Copyright (C) <year> <name of author>\r
+\r
+ This library is free software; you can redistribute it and/or\r
+ modify it under the terms of the GNU Lesser General Public\r
+ License as published by the Free Software Foundation; either\r
+ version 2.1 of the License, or (at your option) any later version.\r
+\r
+ This library is distributed in the hope that it will be useful,\r
+ but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r
+ Lesser General Public License for more details.\r
+\r
+ You should have received a copy of the GNU Lesser General Public\r
+ License along with this library; if not, write to the Free Software\r
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r
+\r
+Also add information on how to contact you by electronic and paper mail.\r
+\r
+You should also get your employer (if you work as a programmer) or your\r
+school, if any, to sign a "copyright disclaimer" for the library, if\r
+necessary. Here is a sample; alter the names:\r
+\r
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the\r
+ library `Frob' (a library for tweaking knobs) written by James Random Hacker.\r
+\r
+ <signature of Ty Coon>, 1 April 1990\r
+ Ty Coon, President of Vice\r
+\r
+That's all there is to it!\r
+\r
+\r
--- /dev/null
+The contents of this directory are extracted from
+the official LZMA SDK, version lzma442.tar.bz2 ,
+for the use in mkccbfs.
--- /dev/null
+##
+## This file is part of the coreboot project.
+##
+## Copyright (C) 2007 coresystems GmbH
+##
+## This program is free software; you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation; either version 2 of the License, or
+## (at your option) any later version.
+##
+## This program 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 General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program; if not, write to the Free Software
+## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+##
+
+LZMA_OBJ := lzma/LZMAEncoder.o lzma/LZInWindow.o
+LZMA_OBJ += lzma/RangeCoderBit.o lzma/StreamUtils.o
+LZMA_OBJ += lzma/OutBuffer.o lzma/Alloc.o
+LZMA_OBJ += lzma/CRC.o
+LZMA_OBJ += lzma/lzma-compress.o
+
+$(tobj)/lzma/lzma-compress.o: $(tsrc)/lzma/minilzma.cc
+ $(CXX) $(CFLAGS) -o $@ -c -DCOMPACT $<
+
+$(tobj)/lzma/%.o: $(tsrc)/lzma/C/7zip/Compress/LZMA/%.cpp
+ $(CXX) $(CFLAGS) -o $@ -c $<
+
+$(tobj)/lzma/%.o: $(tsrc)/lzma/C/7zip/Compress/LZ/%.cpp
+ $(CXX) $(CFLAGS) -o $@ -c $<
+
+$(tobj)/lzma/%.o: $(tsrc)/lzma/C/7zip/Compress/RangeCoder/%.cpp
+ $(CXX) $(CFLAGS) -o $@ -c $<
+
+$(tobj)/lzma/%.o: $(tsrc)/lzma/C/7zip/Decompress/%.cpp
+ $(CXX) $(CFLAGS) -o $@ -c $<
+
+$(tobj)/lzma/%.o: $(tsrc)/lzma/C/7zip/Common/%.cpp
+ $(CXX) $(CFLAGS) -o $@ -c $<
+
+$(tobj)/lzma/%.o: $(tsrc)/lzma/C/Common/%.cpp
+ $(CXX) $(CFLAGS) -o $@ -c $<
+
+$(tobj)/lzma/%.o: $(tsrc)/lzma/%.cc
+ $(CXX) $(CFLAGS) -o $@ -c $<
+
--- /dev/null
+/*
+ * minimal lzma implementation
+ *
+ * Copyright (C) 2002 Eric Biederman
+ * Copyright (C) 2005 Joel Yliluoma
+ * Copyright (C) 2007 coresystems GmbH
+ * (Adapted by Stefan Reinauer <stepan@coresystems.de> for coresystems GmbH)
+ * Copyright (C) 2007 Patrick Georgi <patrick@georgi-clan.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include "C/Common/MyInitGuid.h"
+#include "C/7zip/Compress/LZMA/LZMAEncoder.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <errno.h>
+#include <cstring>
+#include <cstdio>
+#include <cstdlib>
+#include <cctype>
+
+#include <vector>
+#include <algorithm>
+#include <stdint.h>
+
+const std::vector<unsigned char> LZMACompress
+ (const std::vector<unsigned char>& buf);
+
+const std::vector<unsigned char> LZMADeCompress
+ (const std::vector<unsigned char>& buf);
+
+static inline uint16_t R16(const void* p)
+{
+ const unsigned char* data = (const unsigned char*)p;
+ return (data[0] << 0) | (data[1] << 8);
+}
+static inline uint32_t R32(const void* p)
+{
+ const unsigned char* data = (const unsigned char*)p;
+ return R16(data) | (R16(data+2) << 16);
+}
+
+#define L (uint64_t)
+
+static inline uint64_t R64(const void* p)
+{
+ const unsigned char* data = (const unsigned char*)p;
+ return (L R32(data)) | ((L R32(data+4)) << 32);
+}
+
+#undef L
+
+static UInt32 SelectDictionarySizeFor(unsigned datasize)
+{
+ #if 1
+ return datasize;
+ #else
+#ifdef __GNUC__
+ /* gnu c can optimize this switch statement into a fast binary
+ * search, but it cannot do so for the list of the if statements.
+ */
+ switch(datasize)
+ {
+ case 0 ... 512 : return 512;
+ case 513 ... 1024: return 2048;
+ case 1025 ... 4096: return 8192;
+ case 4097 ... 16384: return 32768;
+ case 16385 ... 65536: return 528288;
+ case 65537 ... 528288: return 1048576*4;
+ case 528289 ... 786432: return 1048576*16;
+ default: return 1048576*32;
+ }
+#else
+ if(datasize <= 512) return 512;
+ if(datasize <= 1024) return 1024;
+ if(datasize <= 4096) return 4096;
+ if(datasize <= 16384) return 32768;
+ if(datasize <= 65536) return 528288;
+ if(datasize <= 528288) return 1048576*4;
+ if(datasize <= 786432) reutrn 1048576*16;
+ return 32*1048576;
+#endif
+ #endif
+}
+
+
+class CInStreamRam: public ISequentialInStream, public CMyUnknownImp
+{
+ const std::vector<unsigned char>& input;
+ size_t Pos;
+public:
+ MY_UNKNOWN_IMP
+
+ CInStreamRam(const std::vector<unsigned char>& buf) : input(buf), Pos(0)
+ {
+ }
+ virtual ~CInStreamRam() {}
+
+ STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+};
+
+STDMETHODIMP CInStreamRam::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+ UInt32 remain = input.size() - Pos;
+ if (size > remain) size = remain;
+
+ std::memcpy(data, &input[Pos], size);
+ Pos += size;
+
+ if(processedSize != NULL) *processedSize = size;
+
+ return S_OK;
+}
+
+class COutStreamRam: public ISequentialOutStream, public CMyUnknownImp
+{
+ std::vector<Byte> result;
+ size_t Pos;
+public:
+ MY_UNKNOWN_IMP
+
+ COutStreamRam(): result(), Pos(0) { }
+ virtual ~COutStreamRam() { }
+
+ void Reserve(unsigned n) { result.reserve(n); }
+ const std::vector<Byte>& Get() const { return result; }
+
+ HRESULT WriteByte(Byte b)
+ {
+ if(Pos >= result.size()) result.resize(Pos+1);
+ result[Pos++] = b;
+ return S_OK;
+ }
+
+ STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+};
+
+STDMETHODIMP COutStreamRam::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+ if(Pos+size > result.size()) result.resize(Pos+size);
+
+ std::memcpy(&result[Pos], data, size);
+ if(processedSize != NULL) *processedSize = size;
+ Pos += size;
+ return S_OK;
+}
+
+const std::vector<unsigned char> LZMACompress(const std::vector<unsigned char>& buf)
+{
+ if(buf.empty()) return buf;
+
+ const UInt32 dictionarysize = SelectDictionarySizeFor(buf.size());
+
+ NCompress::NLZMA::CEncoder *encoderSpec = new NCompress::NLZMA::CEncoder;
+ CMyComPtr<ICompressCoder> encoder = encoderSpec;
+ const PROPID propIDs[] =
+ {
+ NCoderPropID::kAlgorithm,
+ NCoderPropID::kDictionarySize,
+ NCoderPropID::kNumFastBytes,
+ };
+ const unsigned kNumProps = sizeof(propIDs) / sizeof(propIDs[0]);
+ PROPVARIANT properties[kNumProps];
+ properties[0].vt = VT_UI4; properties[0].ulVal = (UInt32)2;
+ properties[1].vt = VT_UI4; properties[1].ulVal = (UInt32)dictionarysize;
+ properties[2].vt = VT_UI4; properties[2].ulVal = (UInt32)64;
+
+ if (encoderSpec->SetCoderProperties(propIDs, properties, kNumProps) != S_OK)
+ {
+ Error:
+ return std::vector<unsigned char> ();
+ }
+
+ COutStreamRam *const outStreamSpec = new COutStreamRam;
+ CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
+ CInStreamRam *const inStreamSpec = new CInStreamRam(buf);
+ CMyComPtr<ISequentialInStream> inStream = inStreamSpec;
+
+ outStreamSpec->Reserve(buf.size());
+
+ if (encoderSpec->WriteCoderProperties(outStream) != S_OK) goto Error;
+
+ for (unsigned i = 0; i < 8; i++)
+ {
+ UInt64 t = (UInt64)buf.size();
+ outStreamSpec->WriteByte((Byte)((t) >> (8 * i)));
+ }
+
+ HRESULT lzmaResult = encoder->Code(inStream, outStream, 0, 0, 0);
+ if (lzmaResult != S_OK) goto Error;
+
+ return outStreamSpec->Get();
+}
+
+#undef RC_NORMALIZE
+
+#include "C/7zip/Decompress/LzmaDecode.h"
+#include "C/7zip/Decompress/LzmaDecode.c"
+
+const std::vector<unsigned char> LZMADeCompress
+ (const std::vector<unsigned char>& buf)
+{
+ if(buf.size() <= 5+8) return std::vector<unsigned char> ();
+
+ uint_least64_t out_sizemax = R64(&buf[5]);
+
+ std::vector<unsigned char> result(out_sizemax);
+
+ CLzmaDecoderState state;
+ LzmaDecodeProperties(&state.Properties, &buf[0], LZMA_PROPERTIES_SIZE);
+ state.Probs = new CProb[LzmaGetNumProbs(&state.Properties)];
+
+ SizeT in_done;
+ SizeT out_done;
+ LzmaDecode(&state, &buf[13], buf.size()-13, &in_done,
+ &result[0], result.size(), &out_done);
+
+ delete[] state.Probs;
+
+ result.resize(out_done);
+ return result;
+}
+
+#ifndef COMPACT
+int main(int argc, char *argv[])
+{
+ char *s;
+ FILE *f, *infile, *outfile;
+ int c;
+
+ if (argc != 4) {
+ std::fprintf(stderr, "'lzma e file1 file2' encodes file1 into file2.\n"
+ "'lzma d file2 file1' decodes file2 into file1.\n");
+
+ return EXIT_FAILURE;
+ }
+ if (argc == 4) {
+ if ((s = argv[1], s[1] || strpbrk(s, "DEde") == NULL)
+ || (s = argv[2], (infile = fopen(s, "rb")) == NULL)
+ || (s = argv[3], (outfile = fopen(s, "wb")) == NULL)) {
+ std::fprintf(stderr, "??? %s\n", s);
+ return EXIT_FAILURE;
+ }
+ }
+
+ struct stat fs;
+ int si;
+ if (fstat(fileno(infile), &fs)) {
+ std::perror(strerror(errno));
+ return EXIT_FAILURE;
+ }
+ si=fs.st_size;
+
+ char *Buf=(char *)malloc(si);
+ fread(Buf,si, 1, infile);
+
+ std::vector<unsigned char> result;
+ if (toupper(*argv[1]) == 'E')
+ result = LZMACompress(std::vector<unsigned char>(Buf,Buf+si));
+ else
+ result = LZMADeCompress(std::vector<unsigned char>(Buf,Buf+si));
+
+ fwrite(&result[0], result.size(), 1, outfile);
+ fclose(infile);
+ fclose(outfile);
+ return EXIT_SUCCESS;
+}
+#else
+extern "C" {
+
+/**
+ * Compress a buffer with lzma
+ * Don't copy the result back if it is too large.
+ * @param in a pointer to the buffer
+ * @param in_len the length in bytes
+ * @param out a pointer to a buffer of at least size in_len
+ * @param out_len a pointer to the compressed length of in
+ */
+
+void do_lzma_compress(char *in, int in_len, char *out, int *out_len) {
+ std::vector<unsigned char> result;
+ result = LZMACompress(std::vector<unsigned char>(in, in + in_len));
+ *out_len = result.size();
+ if (*out_len < in_len)
+ std::memcpy(out, &result[0], *out_len);
+}
+
+void do_lzma_uncompress(char *dst, int dst_len, char *src, int src_len) {
+ std::vector<unsigned char> result;
+ result = LZMADeCompress(std::vector<unsigned char>(src, src + src_len));
+ if (result.size() <= dst_len)
+ std::memcpy(dst, &result[0], result.size());
+ else
+ {
+ fprintf(stderr, "Not copying %d bytes to %d-byte buffer!\n",
+ result.size(), dst_len);
+ exit(1);
+ }
+}
+
+}
+#endif
+
--- /dev/null
+/*
+ * rom-mkpayload
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "elf.h"
+#include <fcntl.h>
+#include <getopt.h>
+#include <sys/stat.h>
+#include <arpa/inet.h>
+
+#include "common.h"
+#include "../cbfs.h"
+
+int parse_elf(unsigned char *input, unsigned char **output, int algo,
+ void (*compress) (char *, int, char *, int *))
+{
+ Elf32_Phdr *phdr;
+ Elf32_Ehdr *ehdr;
+ Elf32_Shdr *shdr;
+ char *header;
+ char *strtab;
+ unsigned char *sptr;
+ int headers;
+ int segments = 1;
+ int isize = 0, osize = 0;
+ int doffset = 0;
+ struct cbfs_payload_segment *segs;
+ int i;
+
+ ehdr = (Elf32_Ehdr *) input;
+ headers = ehdr->e_phnum;
+ header = (char *)ehdr;
+
+ phdr = (Elf32_Phdr *) & (header[ehdr->e_phoff]);
+ shdr = (Elf32_Shdr *) & (header[ehdr->e_shoff]);
+
+ strtab = &header[shdr[ehdr->e_shstrndx].sh_offset];
+
+ /* Count the number of headers - look for the .notes.pinfo
+ * section */
+
+ for (i = 0; i < ehdr->e_shnum; i++) {
+ char *name;
+
+ if (i == ehdr->e_shstrndx)
+ continue;
+
+ if (shdr[i].sh_size == 0)
+ continue;
+
+ name = (char *)(strtab + shdr[i].sh_name);
+
+ if (!strcmp(name, ".note.pinfo"))
+ segments++;
+ }
+
+ /* Now, regular headers - we only care about PT_LOAD headers,
+ * because thats what we're actually going to load
+ */
+
+ for (i = 0; i < headers; i++) {
+ if (phdr[i].p_type != PT_LOAD)
+ continue;
+
+ /* Empty segments are never interesting */
+ if (phdr[i].p_memsz == 0)
+ continue;
+
+ isize += phdr[i].p_filesz;
+
+ segments++;
+ }
+
+ /* Allocate a block of memory to store the data in */
+
+ sptr =
+ calloc((segments * sizeof(struct cbfs_payload_segment)) + isize,
+ 1);
+ doffset = (segments * sizeof(struct cbfs_payload_segment));
+
+ if (sptr == NULL)
+ goto err;
+
+ segs = (struct cbfs_payload_segment *)sptr;
+ segments = 0;
+
+ for (i = 0; i < ehdr->e_shnum; i++) {
+ char *name;
+
+ if (i == ehdr->e_shstrndx)
+ continue;
+
+ if (shdr[i].sh_size == 0)
+ continue;
+
+ name = (char *)(strtab + shdr[i].sh_name);
+
+ if (!strcmp(name, ".note.pinfo")) {
+ segs[segments].type = PAYLOAD_SEGMENT_PARAMS;
+ segs[segments].load_addr = 0;
+ segs[segments].len = (unsigned int)shdr[i].sh_size;
+ segs[segments].offset = doffset;
+
+ memcpy((unsigned long *)(sptr + doffset),
+ &header[shdr[i].sh_offset], shdr[i].sh_size);
+
+ doffset += segs[segments].len;
+ osize += segs[segments].len;
+
+ segments++;
+ }
+ }
+
+ for (i = 0; i < headers; i++) {
+ if (phdr[i].p_type != PT_LOAD)
+ continue;
+
+ if (phdr[i].p_memsz == 0)
+ continue;
+
+ if (phdr[i].p_filesz == 0) {
+ segs[segments].type = PAYLOAD_SEGMENT_BSS;
+ segs[segments].load_addr =
+ (unsigned long long)htonl(phdr[i].p_paddr);
+ segs[segments].mem_len = (unsigned int)htonl(phdr[i].p_memsz);
+ segs[segments].offset = htonl(doffset);
+
+ segments++;
+ continue;
+ }
+
+ segs[segments].type = PAYLOAD_SEGMENT_DATA;
+ segs[segments].load_addr = (unsigned int)htonl(phdr[i].p_paddr);
+ segs[segments].mem_len = (unsigned int)htonl(phdr[i].p_memsz);
+ segs[segments].compression = htonl(algo);
+ segs[segments].offset = htonl(doffset);
+
+ int len;
+ compress((char *)&header[phdr[i].p_offset],
+ phdr[i].p_filesz,
+ (char *)(sptr + doffset), &len);
+ segs[segments].len = htonl(len);
+
+ /* If the compressed section is larger, then use the
+ original stuff */
+
+ if ((unsigned int)len > phdr[i].p_filesz) {
+ segs[segments].compression = 0;
+ segs[segments].len = htonl(phdr[i].p_filesz);
+
+ memcpy((char *)(sptr + doffset),
+ &header[phdr[i].p_offset], phdr[i].p_filesz);
+ }
+
+ doffset += ntohl(segs[segments].len);
+ osize += ntohl(segs[segments].len);
+
+ segments++;
+ }
+
+ segs[segments].type = PAYLOAD_SEGMENT_ENTRY;
+ segs[segments++].load_addr = (unsigned long long)htonl(ehdr->e_entry);
+
+ *output = sptr;
+
+ return (segments * sizeof(struct cbfs_payload_segment)) + osize;
+
+err:
+ return -1;
+}
+
+int main(int argc, char **argv)
+{
+ void (*compress) (char *, int, char *, int *);
+ int algo;
+
+ char *output = NULL;
+ char *input = NULL;
+
+ unsigned char *buffer, *obuffer;
+ int size, osize;
+
+ while (1) {
+ int option_index;
+ static struct option longopt[] = {
+ {"output", 1, 0, 'o'},
+ {"lzma", 0, 0, 'l'},
+ {"nocompress", 0, 0, 'n'},
+ };
+
+ signed char ch = getopt_long(argc, argv, "o:ln",
+ longopt, &option_index);
+
+ if (ch == -1)
+ break;
+
+ switch (ch) {
+ case 'o':
+ output = optarg;
+ break;
+ case 'l':
+ algo = CBFS_COMPRESS_LZMA;
+ break;
+ case 'n':
+ algo = CBFS_COMPRESS_NONE;
+ break;
+ default:
+ //usage();
+ return -1;
+ }
+ }
+
+ if (optind < argc)
+ input = argv[optind];
+
+ if (input == NULL || !strcmp(input, "-"))
+ buffer = file_read_to_buffer(STDIN_FILENO, &size);
+ else {
+ printf("Reading from %s\n", input);
+ buffer = file_read(input, &size);
+ }
+
+ if (!iself(buffer)) {
+ fprintf(stderr, "E: This does not appear to be an ELF file\n");
+ return -1;
+ }
+
+ switch (algo) {
+ case CBFS_COMPRESS_NONE:
+ compress = none_compress;
+ break;
+ case CBFS_COMPRESS_LZMA:
+ compress = lzma_compress;
+ break;
+ }
+
+ osize = parse_elf(buffer, &obuffer, algo, compress);
+
+ if (osize == -1) {
+ fprintf(stderr, "E: Error while converting the payload\n");
+ return -1;
+ }
+
+ if (output == NULL || !strcmp(output, "-"))
+ file_write_from_buffer(STDOUT_FILENO, obuffer, osize);
+ else
+ file_write(output, obuffer, osize);
+
+ return 0;
+}
--- /dev/null
+/*
+ * rom-mkstage
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "elf.h"
+#include <fcntl.h>
+#include <getopt.h>
+#include <sys/stat.h>
+
+#include "common.h"
+#include "../cbfs.h"
+
+int parse_elf(unsigned char *input, unsigned char **output,
+ int mode, void (*compress) (char *, int, char *, int *))
+{
+ Elf32_Phdr *phdr;
+ Elf32_Ehdr *ehdr = (Elf32_Ehdr *) input;
+ Elf32_Shdr *shdr;
+ char *header, *buffer;
+ unsigned char *out;
+
+ int headers;
+ int i;
+ struct cbfs_stage *stage;
+ unsigned int data_start, data_end, mem_end;
+
+ headers = ehdr->e_phnum;
+ header = (char *)ehdr;
+
+ phdr = (Elf32_Phdr *) & (header[ehdr->e_phoff]);
+ shdr = (Elf32_Shdr *) & (header[ehdr->e_shoff]);
+
+ /* Now, regular headers - we only care about PT_LOAD headers,
+ * because thats what we're actually going to load
+ */
+
+ data_start = 0xFFFFFFFF;
+ data_end = 0;
+ mem_end = 0;
+
+ for (i = 0; i < headers; i++) {
+ unsigned int start, mend, rend;
+
+ if (phdr[i].p_type != PT_LOAD)
+ continue;
+
+ /* Empty segments are never interesting */
+ if (phdr[i].p_memsz == 0)
+ continue;
+
+ /* BSS */
+
+ start = phdr[i].p_paddr;
+
+ mend = start + phdr[i].p_memsz;
+ rend = start + phdr[i].p_filesz;
+
+ if (start < data_start)
+ data_start = start;
+
+ if (rend > data_end)
+ data_end = rend;
+
+ if (mend > mem_end)
+ mem_end = mend;
+ }
+
+ /* allocate an intermediate buffer for the data */
+ buffer = calloc(data_end - data_start, 1);
+
+ if (buffer == NULL) {
+ fprintf(stderr, "E: Unable to allocate memory: %m\n");
+ return -1;
+ }
+
+ /* Copy the file data into the buffer */
+
+ for (i = 0; i < headers; i++) {
+
+ if (phdr[i].p_type != PT_LOAD)
+ continue;
+
+ if (phdr[i].p_memsz == 0)
+ continue;
+
+ memcpy(buffer + (phdr[i].p_paddr - data_start),
+ &header[phdr[i].p_offset], phdr[i].p_filesz);
+ }
+
+ /* Now make the output buffer */
+ out = calloc(sizeof(struct cbfs_stage) + data_end - data_start, 1);
+
+ if (out == NULL) {
+ fprintf(stderr, "E: Unable to allocate memory: %m\n");
+ return -1;
+ }
+
+ stage = (struct cbfs_stage *)out;
+
+ stage->load = data_start;
+ stage->memlen = mem_end - data_start;
+ stage->compression = mode;
+ stage->entry = ehdr->e_entry;
+
+ compress(buffer, data_end - data_start,
+ (char *)(out + sizeof(struct cbfs_stage)),
+ (int *)&stage->len);
+
+ *output = out;
+
+ return sizeof(struct cbfs_stage) + stage->len;
+}
+
+int main(int argc, char **argv)
+{
+ void (*compress) (char *, int, char *, int *);
+ int algo = CBFS_COMPRESS_LZMA;
+
+ char *output = NULL;
+ char *input = NULL;
+
+ unsigned char *buffer, *obuffer;
+ int size, osize;
+
+ while (1) {
+ int option_index;
+ static struct option longopt[] = {
+ {"output", 1, 0, 'o'},
+ {"lzma", 0, 0, 'l'},
+ {"nocompress", 0, 0, 'n'},
+ };
+
+ signed char ch = getopt_long(argc, argv, "o:ln",
+ longopt, &option_index);
+
+ if (ch == -1)
+ break;
+
+ switch (ch) {
+ case 'o':
+ output = optarg;
+ break;
+ case 'l':
+ algo = CBFS_COMPRESS_LZMA;
+ break;
+ case 'n':
+ algo = CBFS_COMPRESS_NONE;
+ break;
+ default:
+ //usage();
+ return -1;
+ }
+ }
+
+ if (optind < argc)
+ input = argv[optind];
+
+ if (input == NULL || !strcmp(input, "-"))
+ buffer = file_read_to_buffer(STDIN_FILENO, &size);
+ else
+ buffer = file_read(input, &size);
+
+ if (!iself(buffer)) {
+ fprintf(stderr, "E: The incoming file is not an ELF\n");
+ return -1;
+ }
+
+ switch (algo) {
+ case CBFS_COMPRESS_NONE:
+ compress = none_compress;
+ break;
+ case CBFS_COMPRESS_LZMA:
+ compress = lzma_compress;
+ break;
+ }
+
+ osize = parse_elf(buffer, &obuffer, algo, compress);
+
+ if (osize == -1) {
+ fprintf(stderr, "E: Error while converting the ELF\n");
+ return -1;
+ }
+
+ if (output == NULL || !strcmp(output, "-"))
+ file_write_from_buffer(STDOUT_FILENO, obuffer, osize);
+ else
+ file_write(output, obuffer, osize);
+
+ return 0;
+}
--- /dev/null
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <string.h>
+#include "cbfstool.h"
+
+static const struct {
+ char *type;
+ unsigned int value;
+ int (*detect) (const char *filename);
+ int (*handler) (const char *filename, const char *name);
+} component_types[] = {
+ {
+NULL, 0xFF, NULL, NULL},};
+
+int parse_type(const char *str, unsigned int *type)
+{
+ int i;
+ for (i = 0; component_types[i].type != NULL; i++) {
+ if (!strncmp(str, component_types[i].type,
+ strlen(compoent_types[i].type))) {
+ *type = component_types[i].value;
+ return 0;
+ }
+ }
+
+ return -1;
+}
+
+int detect_type(const char *filename)
+{
+
+ int i;
+
+ for (i = 0; component_types[i].type != NULL; i++) {
+ if (component_types[i].detect &&
+ !component_types[i].detect(filename))
+ return component_types[i].value;
+
+ }
+}
+
+int handle_type(const char *filename, int type, int *ret)
+{
+ /* Now send the file to the required handler */
+ for (i = 0; component_types[i].type != NULL; i++) {
+ if (type == component_types[i].value) {
+ *ret = component_types[i].handler(config,
+ argv[0], argv[1]);
+ return 0;
+ }
+ }
+
+ return -1;
+}
+
+void get_type(int type, char *buffer, int len)
+{
+ for (i = 0; component_types[i].type != NULL; i++) {
+ if (type == component_types[i].value) {
+ strncpy(buffer, component_types[i].type, len - 1);
+ buffer[len - 1] = '\0';
+ return;
+ }
+ }
+
+ snprintf(buffer, len, "%x\n", type);
+}
--- /dev/null
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include "cbfstool.h"
+
+int get_size(const char *size)
+{
+ char *next;
+ int val = strtoul(size, &next, 0);
+
+ /* Support modifiers for the size kK and mM for kbytes and
+ mbytes respectfully */
+
+ if (next != NULL) {
+ if (*next == 'k' || *next == 'K')
+ val *= 1024;
+ else if (*next == 'm' || *next == 'M')
+ val *= (1024 * 1024);
+ }
+
+ return val;
+}
+
+int copy_from_fd(int fd, void *ptr, int size)
+{
+ unsigned char *p = ptr;
+
+ while (size > 0) {
+ int ret = read(fd, p, size);
+
+ if (ret == -1) {
+ ERROR("Error while reading: %m\n");
+ return -1;
+ }
+
+ if (ret == 0) {
+ ERROR("Unexpected end of file\n");
+ return -1;
+ }
+
+ p += ret;
+ size -= ret;
+ }
+
+ return 0;
+}
+
+int size_and_open(const char *filename, unsigned int *size)
+{
+ struct stat s;
+
+ int fd = open(filename, O_RDONLY);
+
+ if (fd == -1) {
+ ERROR("Unable to open %s: %m\n", filename);
+ return -1;
+ }
+
+ if (fstat(fd, &s)) {
+ ERROR("Unable to stat %s: %m\n", filename);
+ close(fd);
+ return -1;
+ }
+
+ *size = s.st_size;
+ return fd;
+}
+
+int map_rom(struct rom *rom, int size)
+{
+ rom->ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED,
+ rom->fd, 0);
+
+ if (rom->ptr == MAP_FAILED) {
+ ERROR("Could not map the rom: %m\n");
+ rom->ptr = NULL;
+ return -1;
+ }
+
+ return 0;
+}
+
+int open_rom(struct rom *rom, const char *filename)
+{
+ struct stat s;
+ unsigned long offset;
+
+ if (stat(filename, &s)) {
+ ERROR("Could not stat %s: %m\n", filename);
+ return -1;
+ }
+
+ rom->fd = open(filename, O_RDWR);
+
+ if (rom->fd == -1) {
+ ERROR("Could not open %s: %m\n", filename);
+ rom->fd = 0;
+ return -1;
+ }
+
+ if (map_rom(rom, s.st_size))
+ goto err;
+
+ /* Find the master header */
+
+ offset = ROM_READL(rom, s.st_size - 4);
+
+ rom->header = (struct cbfs_header *)
+ ROM_PTR(rom, s.st_size - (0xFFFFFFFF - offset) - 1);
+
+ if (ntohl(rom->header->magic) != HEADER_MAGIC) {
+ ERROR("This does not appear to be a valid ROM\n");
+ goto err;
+ }
+
+ /* Check that the alignment is correct */
+ if (ntohl(rom->header->align) == 0) {
+ ERROR("The alignment in the ROM is 0 - probably malformed\n");
+ goto err;
+ }
+
+ /* Sanity check that the size matches the file size */
+
+ if (ntohl(rom->header->romsize) != s.st_size) {
+ ERROR("The ROM size in the header does not match the file\n");
+ ERROR("ROM size is %d bytes, file size is %d bytes\n",
+ ntohl(rom->header->romsize), (unsigned int)s.st_size);
+ goto err;
+ }
+
+ rom->size = ntohl(rom->header->romsize);
+ rom->fssize = rom->size - ntohl(rom->header->bootblocksize);
+
+ return 0;
+
+err:
+ if (rom->ptr != NULL)
+ munmap(rom->ptr, s.st_size);
+
+ if (rom->fd > 0)
+ close(rom->fd);
+
+ rom->ptr = NULL;
+ rom->fd = 0;
+ return -1;
+}
+
+int create_rom(struct rom *rom, const unsigned char *filename,
+ int romsize, int bootblocksize, int align)
+{
+ unsigned char null = '\0';
+
+ if (rom->fd != 0) {
+ ERROR("%s already exists - cannot create\n", filename);
+ return -1;
+ }
+
+ /* Remember the size of the entire ROM */
+ rom->size = romsize;
+
+ /* The size of the archive section is everything but the bootblock */
+ rom->fssize = romsize - bootblocksize;
+
+ /* Open the file descriptor */
+
+ rom->fd = open((char *)filename, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
+
+ if (rom->fd == -1) {
+ ERROR("Could not create %s: %m\n", filename);
+ return -1;
+ }
+
+ /* Size the new file appropriately */
+ lseek(rom->fd, romsize - 1, SEEK_SET);
+ write(rom->fd, &null, 1);
+
+ if (map_rom(rom, romsize)) {
+ close(rom->fd);
+ return -1;
+ }
+
+ /* Clear the reset vector */
+ memset(rom->ptr + rom->size - 16, 0, 16);
+
+ ROM_WRITEL(rom, rom->size - 4,
+ 0xFFFFFFF0 - sizeof(struct cbfs_header));
+
+ /* This is a pointer to the header for easy access */
+ rom->header = (struct cbfs_header *)
+ ROM_PTR(rom, rom->size - 16 - sizeof(struct cbfs_header));
+
+ rom->header->magic = htonl(HEADER_MAGIC);
+ rom->header->romsize = htonl(romsize);
+ rom->header->bootblocksize = htonl(bootblocksize);
+ rom->header->align = htonl(align);
+ rom->header->offset = htonl(0);
+
+ return 0;
+}
+
+int add_bootblock(struct rom *rom, const char *filename)
+{
+ unsigned int size;
+ //unsigned int offset;
+ int fd = size_and_open(filename, &size);
+ int ret;
+ struct cbfs_header tmp;
+
+ if (fd == -1)
+ return -1;
+
+ if (size > ntohl(rom->header->bootblocksize)) {
+ ERROR("The bootblock size is not correct (%d vs %d)\n",
+ size, ntohl(rom->header->bootblocksize));
+ return -1;
+ }
+
+ /* Copy the current header into a temporary buffer */
+ memcpy(&tmp, rom->header, sizeof(struct cbfs_header));
+
+ /* Copy the bootblock into place at the end of the file */
+
+ ret = copy_from_fd(fd, ROM_PTR(rom, rom->size - ntohl(rom->header->bootblocksize)), size);
+
+ close(fd);
+
+ if (ret) {
+ ERROR("Unable to add %s to the bootblock\n", filename);
+ return -1;
+ }
+
+ /* FIXME: This should point to a location defined by coreboot */
+
+ ROM_WRITEL(rom, rom->size - 4,
+ 0xFFFFFFF0 - sizeof(struct cbfs_header));
+
+ /* This is a pointer to the header for easy access */
+ rom->header = (struct cbfs_header *)
+ ROM_PTR(rom, rom->size - 16 - sizeof(struct cbfs_header));
+
+#if 0
+ /* Figure out the new location for the header */
+ offset = ROM_READL(rom, rom->size - 4);
+
+ rom->header = (struct cbfs_header *)
+ ROM_PTR(rom, offset - (0xFFFFFFFF - rom->size));
+#endif
+
+ /* Replace the LAR header */
+ memcpy(rom->header, &tmp, sizeof(struct cbfs_header));
+
+ return 0;
+}
+
+int rom_exists(struct rom *rom)
+{
+ if (rom->fd <= 0)
+ return 0;
+ return 1;
+}
+++ /dev/null
- rm coreboot.rom;
-./romtool coreboot.rom create 0x80000 0x10000 /tmp/coreboot.strip
-./romtool coreboot.rom add-payload /tmp/filo.elf normal/payload l
-./romtool coreboot.rom print
-#./romtool coreboot.rom add-stage /tmp/filo.elf normal/payload
-
-./romtool coreboot.rom print
-cp coreboot.rom /home/rminnich/qemutest/
+++ /dev/null
-#
-#
-#
-
-obj ?= $(shell pwd)
-
-COMMANDS=create.o bootblock.o delete.o add.o print.o resize.o
-OBJ=$(COMMANDS) romtool.o util.o fs.o
-INC=romtool.h romfs.h
-
-CC=gcc
-CFLAGS=-g -Wall # -W -Werror
-
-DESTDIR ?= /usr/local/bin
-
-all: $(obj)/romtool $(obj)/tools/rom-mkpayload $(obj)/tools/rom-mkstage
-
-$(obj)/romtool: $(patsubst %,$(obj)/%,$(OBJ))
- $(CC) -o $@ $(patsubst %,$(obj)/%,$(OBJ))
-
-tobj = $(obj)/tools
-tsrc = $(shell pwd)/tools
-
-include $(tsrc)/Makefile
-
-$(obj)/%.o: %.c $(INC)
- $(CC) $(CFLAGS) -c -o $@ $<
-
-install: $(obj)/romtool $(obj)/tools/rom-mkpayload $(obj)/tools/rom-mkstage
- @ install -d $(DESTDIR)
- @ install -m 0755 $(obj)/romtool $(DESTDIR)/romtool
- @ install -m 0755 $(obj)/tools/rom-mkstage $(DESTDIR)/rom-mkstage
- @ install -m 0755 $(obj)/tools/rom-mkpayload $(DESTDIR)/rom-mkpayload
-
-tags:
- ctags *.[ch] */*.[ch]
-
-clean: tools-clean
- rm -f $(patsubst %,$(obj)/%,$(OBJ)) $(obj)/romtool
-
+++ /dev/null
-Coreboot ROMFS Specification
-Jordan Crouse <jordan@cosmicpenguin.net>
-
-= Introduction =
-
-This document describes the coreboot ROMFS specification (from here referred
-to as ROMFS). ROMFS is a scheme for managing independent chunks of data in
-a system ROM. Though not a true filesystem, the style and concepts are
-similar.
-
-= Architecture =
-
-The ROMFS architecture looks like the following:
-
-/---------------\ <-- Start of ROM
-| /-----------\ | --|
-| | Header | | |
-| |-----------| | |
-| | Name | | |-- Component
-| |-----------| | |
-| |Data | | |
-| |.. | | |
-| \-----------/ | --|
-| |
-| /-----------\ |
-| | Header | |
-| |-----------| |
-| | Name | |
-| |-----------| |
-| |Data | |
-| |.. | |
-| \-----------/ |
-| |
-| ... |
-| /-----------\ |
-| | | |
-| | Bootblock | |
-| | --------- | |
-| | Reset | | <- 0xFFFFFFF0
-| \-----------/ |
-\---------------/
-
-
-The ROMFS architecture consists of a binary associated with a physical
-ROM disk referred hereafter as the ROM. A number of independent of
-components, each with a header prepended on to data are located within
-the ROM. The components are nominally arranged sequentially, though they
-are aligned along a pre-defined boundary.
-
-The bootblock occupies the last 20k of the ROM. Within
-the bootblock is a master header containing information about the ROM
-including the size, alignment of the components, and the offset of the
-start of the first ROMFS component within the ROM.
-
-= Master Header =
-
-The master header contains essential information about the ROM that is
-used by both the ROMFS implementation within coreboot at runtime as well
-as host based utilities to create and manage the ROM. The master header
-will be located somewhere within the bootblock (high end of the ROM). A
-pointer to the location of the header will be located at offset
--4 from the end of the ROM. This translates to address 0xFFFFFFFC on a
-normal x86 system. The pointer will be to physical memory somewhere
-between - 0xFFFF0000 and 0xFFFFFFF0. This makes it easier for coreboot
-to locate the header at run time. Build time utilities will
-need to read the pointer and do the appropriate math to locate the header.
-
-The following is the structure of the master header:
-
-struct romfs_header {
- unsigned int magic;
- unsigned int version;
- unsigned int romsize;
- unsigned int bootblocksize;
- unsigned int align;
- unsigned int offset;
- unsigned int pad[2];
-};
-
-The meaning of each member is as follows:
-
-'magic' is a 32 bit number that identifies the ROM as a ROMFS type. The magic
-number is 0x4F524243, which is 'ORBC' in ASCII.
-
-'version' is a 32 bit number that identifies the version of ROMFS. The current
-version is 0x31313131 ('1111' in ASCII) which is endian-independent.
-
-'romsize' is the size of the ROM in bytes. Coreboot will subtract 'size' from
-0xFFFFFFFF to locate the beginning of the ROM in memory.
-
-'bootblocksize' is the boot block size in bytes. There is no limitation on
-the boot block size as in v3.
-
-'align' is the number of bytes that each component is aligned to within the
-ROM. This is used to make sure that each component is aligned correctly with
-regards to the erase block sizes on the ROM - allowing one to replace a
-component at runtime without disturbing the others.
-
-'offset' is the offset of the the first ROMFS component (from the start of
-the ROM). This is to allow for arbitrary space to be left at the beginning
-of the ROM for things like embedded controller firmware.
-
-'pad' rounds the header to 32 bits and reserves a little room for later use.
-
-= Bootblock =
-The bootblock is a mandatory component in the ROM. It is located in the
-last bootblocksize bytes of ROM space, and contains, among other things,
-the location of the master header and the entry point for the loader
-firmware. The bootblock does not have a component header attached to it.
-
-
-= Components =
-
-ROMFS components are placed in the ROM starting at 'offset' specified in
-the master header and ending at the bootblock. Thus the total size available
-for components in the ROM is (ROM size - bootblocksize - 'offset'). Each ROMFS
-component is to be aligned according to the 'align' value in the header.
-Thus, if a component of size 1052 is located at offset 0 with an 'align' value
-of 1024, the next component will be located at offset 2048.
-
-Each ROMFS component will be indexed with a unique ASCII string name of
-unlimited size.
-
-Each ROMFS component starts with a header:
-
-struct ROMFS_file {
- char magic[8];
- unsigned int len;
- unsigned int type;
- unsigned int checksum;
- unsigned int offset;
-};
-
-'magic' is a magic value used to identify the header. During runtime,
-coreboot will scan the ROM looking for this value. The default magic is
-the string 'LARCHIVE'.
-
-'len' is the length of the data, not including the size of the header and
-the size of the name.
-
-'type' is a 32 bit number indicating the type of data that is attached.
-The data type is used in a number of ways, as detailed in the section
-below.
-
-'checksum' is a 32bit checksum of the entire component, including the
-header and name.
-
-'offset' is the start of the component data, based off the start of the header.
-The difference between the size of the header and offset is the size of the
-component name.
-
-Immediately following the header will be the name of the component, which will
-null terminated and 16 byte aligned. The following picture shows the
-structure of the header:
-
-/--------\ <- start
-| Header |
-|--------| <- sizeof(struct romfs_file)
-| Name |
-|--------| <- 'offset'
-| Data |
-| ... |
-\--------/ <- start + 'offset' + 'len'
-
-== Searching Alogrithm ==
-
-To locate a specific component in the ROM, one starts at the 'offset'
-specified in the ROMFS master header. For this example, the offset will
-be 0.
-
-From that offset, the code should search for the magic string on the
-component, jumping 'align' bytes each time. So, assuming that 'align' is
-16, the code will search for the string 'LARCHIVE' at offset 0, 16, 32, etc.
-If the offset ever exceeds the allowable range for ROMFS components, then no
-component was found.
-
-Upon recognizing a component, the software then has to search for the
-specific name of the component. This is accomplished by comparing the
-desired name with the string on the component located at
-offset + sizeof(struct romfs_file). If the string matches, then the component
-has been located, otherwise the software should add 'offset' + 'len' to
-the offset and resume the search for the magic value.
-
-== Data Types ==
-
-The 'type' member of struct romfs_file is used to identify the content
-of the component data, and is used by coreboot and other
-run-time entities to make decisions about how to handle the data.
-
-There are three component types that are essential to coreboot, and so
-are defined here.
-
-=== Stages ===
-
-Stages are code loaded by coreboot during the boot process. They are
-essential to a successful boot. Stages are comprised of a single blob
-of binary data that is to be loaded into a particular location in memory
-and executed. The uncompressed header contains information about how
-large the data is, and where it should be placed, and what additional memory
-needs to be cleared.
-
-Stages are assigned a component value of 0x10. When coreboot sees this
-component type, it knows that it should pass the data to a sub-function
-that will process the stage.
-
-The following is the format of a stage component:
-
-/--------\
-| Header |
-|--------|
-| Binary |
-| .. |
-\--------/
-
-The header is defined as:
-
-struct romfs_stage {
- unsigned int compression;
- unsigned long long entry;
- unsigned long long load;
- unsigned int len;
- unsigned int memlen;
-};
-
-'compression' is an integer defining how the data is compressed. There
-are three compression types defined by this version of the standard:
-none (0x0), lzma (0x1), and nrv2b (0x02), though additional types may be
-added assuming that coreboot understands how to handle the scheme.
-
-'entry' is a 64 bit value indicating the location where the program
-counter should jump following the loading of the stage. This should be
-an absolute physical memory address.
-
-'load' is a 64 bit value indicating where the subsequent data should be
-loaded. This should be an absolute physical memory address.
-
-'len' is the length of the compressed data in the component.
-
-'memlen' is the amount of memory that will be used by the component when
-it is loaded.
-
-The component data will start immediately following the header.
-
-When coreboot loads a stage, it will first zero the memory from 'load' to
-'memlen'. It will then decompress the component data according to the
-specified scheme and place it in memory starting at 'load'. Following that,
-it will jump execution to the address specified by 'entry'.
-Some components are designed to execute directly from the ROM - coreboot
-knows which components must do that and will act accordingly.
-
-=== Payloads ===
-
-Payloads are loaded by coreboot following the boot process.
-
-Stages are assigned a component value of 0x20. When coreboot sees this
-component type, it knows that it should pass the data to a sub-function
-that will process the payload. Furthermore, other run time
-applications such as 'bayou' may easily index all available payloads
-on the system by searching for the payload type.
-
-
-The following is the format of a stage component:
-
-/-----------\
-| Header |
-| Segment 1 |
-| Segment 2 |
-| ... |
-|-----------|
-| Binary |
-| .. |
-\-----------/
-
-The header is as follows:
-
-struct romfs_payload {
- struct romfs_payload_segment segments;
-}
-
-The header contains a number of segments corresponding to the segments
-that need to be loaded for the payload.
-
-The following is the structure of each segment header:
-
-struct romfs_payload_segment {
- unsigned int type;
- unsigned int compression;
- unsigned int offset;
- unsigned long long load_addr;
- unsigned int len;
- unsigned int mem_len;
-};
-
-'type' is the type of segment, one of the following:
-
-PAYLOAD_SEGMENT_CODE 0x45444F43 The segment contains executable code
-PAYLOAD_SEGMENT_DATA 0x41544144 The segment contains data
-PAYLOAD_SEGMENT_BSS 0x20535342 The memory speicfied by the segment
- should be zeroed
-PAYLOAD_SEGMENT_PARAMS 0x41524150 The segment contains information for
- the payload
-PAYLOAD_SEGMENT_ENTRY 0x52544E45 The segment contains the entry point
- for the payload
-
-'compression' is the compression scheme for the segment. Each segment can
-be independently compressed. There are three compression types defined by
-this version of the standard: none (0x0), lzma (0x1), and nrv2b (0x02),
-though additional types may be added assuming that coreboot understands
-how to handle the scheme.
-
-'offset' is the address of the data within the component, starting from
-the component header.
-
-'load_addr' is a 64 bit value indicating where the segment should be placed
-in memory.
-
-'len' is a 32 bit value indicating the size of the segment within the
-component.
-
-'mem_len' is the size of the data when it is placed into memory.
-
-The data will located immediately following the last segment.
-
-=== Option ROMS ===
-
-The third specified component type will be Option ROMs. Option ROMS will
-have component type '0x30'. They will have no additional header, the
-uncompressed binary data will be located in the data portion of the
-component.
-
-=== NULL ===
-
-There is a 4th component type ,defined as NULL (0xFFFFFFFF). This is
-the "don't care" component type. This can be used when the component
-type is not necessary (such as when the name of the component is unique.
-i.e. option_table). It is recommended that all components be assigned a
-unique type, but NULL can be used when the type does not matter.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+++ /dev/null
-Add interactive mode
-Add script mode (./romtool [ROM] -s script)
-Support compression for stages and payloads
-Add nrv2b
+++ /dev/null
-/*
- * romtool
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#include <ctype.h>
-#include <string.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <signal.h>
-#include <sys/stat.h>
-#include <sys/mman.h>
-#include <sys/wait.h>
-#include "romtool.h"
-
-#define MAX_PATH 255
-
-static int add_from_fd(struct rom *rom, const char *name, int type, int fd)
-{
- unsigned char *buffer = malloc(16 * 1024);
- unsigned char *ptr = buffer;
-
- int size = 0;
- int aloc = 16 * 1024;
- int remain = 16 * 1024;
- int ret;
-
- if (buffer == NULL)
- return -1;
-
- while (1) {
- ret = read(fd, ptr, remain);
-
- if (ret <= 0)
- break;
-
- ptr += ret;
- remain -= ret;
- size += ret;
-
- if (remain == 0) {
- buffer = realloc(buffer, aloc + 16 * 1024);
-
- if (buffer == NULL) {
- ret = -1;
- break;
- }
-
- ptr = buffer + size;
-
- aloc += (16 * 1024);
- remain = 16 * 1024;
- }
- }
-
- if (ret == -1 || size == 0) {
-
- if (buffer != NULL)
- free(buffer);
-
- return -1;
- }
-
- ret = rom_add(rom, name, buffer, size, type);
- free(buffer);
-
- return ret;
-}
-
-int fork_tool_and_add(struct rom *rom, const char *tool, const char *input,
- const char *name, int type, int argc, char **argv)
-{
- int output[2];
- pid_t pid;
- int ret;
- int status;
- char **toolargs;
- int i;
-
- /* Create the pipe */
-
- if (pipe(output)) {
- ERROR("Couldn't create a pipe: %m\n");
- return -1;
- }
-
- toolargs = (char **)malloc((5 + argc) * sizeof(char *));
-
- if (toolargs == NULL) {
- ERROR("Unable to allocate memory: %m\n");
- return -1;
- }
-
- toolargs[0] = (char *)tool;
-
- /* these are args. So they need a - in front */
- for (i = 0; i < argc; i++) {
- /* I wish I had python */
- char *c = malloc(strlen(argv[i])) + 2;
- c[0] = '-';
- strcpy(&c[1], argv[i]);
- c[strlen(argv[i])+1] = 0;
- toolargs[1 + i] = c;
- }
-
- toolargs[1 + argc] = "-o";
- toolargs[2 + argc] = "-";
- toolargs[3 + argc] = (char *)input;
- toolargs[4 + argc] = NULL;
-
- pid = fork();
-
- if (pid == 0) {
-
- /* Set up stdin/stdout for the child */
-
- dup2(output[1], STDOUT_FILENO);
- close(output[0]);
-
- /* Execute the tool */
- if (execv(tool, toolargs)) {
- ERROR("Unable to execute %s: %m\n", tool);
- exit(-1);
- }
-
- exit(0);
- }
-
- free(toolargs);
-
- close(output[1]);
-
- /* Read from the file */
- ret = add_from_fd(rom, name, type, output[0]);
-
- /* Reap the child */
- waitpid(pid, &status, 0);
-
- if (WIFSIGNALED(status)) {
- kill(pid, WTERMSIG(status));
- ERROR("Error while executing %s\n", tool);
- return -1;
- } else if (WEXITSTATUS(status) != 0) {
- ERROR("Error while executing %s: %d\n", tool,
- (int)WEXITSTATUS(status));
- return -1;
- }
-
- return ret;
-}
-
-static int add_blob(struct rom *rom, const char *filename,
- const char *name, int type)
-{
- void *ptr;
- struct stat s;
- int fd, ret;
-
- if (!strcmp(filename, "-"))
- return add_from_fd(rom, name, type, 0);
-
- fd = open(filename, O_RDONLY);
-
- if (fd == -1) {
- ERROR("Could not open %s: %m\n", filename);
- return -1;
- }
-
- if (fstat(fd, &s)) {
- ERROR("Could not stat %s: %m\n", filename);
- close(fd);
- return -1;
- }
-
- ptr = mmap(0, s.st_size, PROT_READ, MAP_SHARED, fd, 0);
-
- if (ptr == MAP_FAILED) {
- ERROR("Unable to map %s: %m\n", filename);
- close(fd);
- return -1;
- }
-
- ret = rom_add(rom, name, ptr, s.st_size, type);
-
- munmap(ptr, s.st_size);
- close(fd);
-
- return ret;
-}
-
-void add_usage(void)
-{
- printf("add [FILE] [NAME] [TYPE]\tAdd a component\n");
-}
-
-void add_stage_usage(void)
-{
- printf("add-stage [FILE] [NAME] [OPTIONS]\tAdd a stage to the ROM\n");
-}
-
-void add_payload_usage(void)
-{
- printf
- ("add-payload [FILE] [NAME] [OPTIONS]\tAdd a payload to the ROM\n");
-}
-
-int add_handler(struct rom *rom, int argc, char **argv)
-{
- unsigned int type = ROMFS_COMPONENT_NULL;
-
- if (argc < 2) {
- add_usage();
- return -1;
- }
-
- if (!rom_exists(rom)) {
- ERROR("You need to create the ROM before adding files to it\n");
- return -1;
- }
-
- /* There are two ways to specify the type - a string or a number */
-
- if (argc == 3) {
- if (isdigit(*(argv[2])))
- type = strtoul(argv[2], 0, 0);
- }
-
- if (type == ROMFS_COMPONENT_NULL)
- WARN("No file type was given for %s - using default\n",
- argv[0]);
-
- return add_blob(rom, argv[0], argv[1], type);
-}
-
-char *find_tool(char *tool)
-{
- static char toolpath[MAX_PATH];
- extern char romtool_bindir[];
-
- snprintf(toolpath, MAX_PATH - 1, "tools/%s", tool);
- if (!access(toolpath, X_OK))
- return toolpath;
-
- snprintf(toolpath, MAX_PATH - 1, "%s/tools/%s", romtool_bindir, tool);
-
- if (!access(toolpath, X_OK))
- return toolpath;
-
- snprintf(toolpath, MAX_PATH - 1, "%s/%s", romtool_bindir, tool);
-
- if (!access(toolpath, X_OK))
- return toolpath;
-
- strncpy(toolpath, tool, MAX_PATH - 1);
- return toolpath;
-}
-
-/* Invoke the rom-mkpayload utility */
-
-int add_payload_handler(struct rom *rom, int argc, char **argv)
-{
- if (argc < 2) {
- add_payload_usage();
- return -1;
- }
-
- /* Make sure the ROM exists */
-
- if (!rom_exists(rom)) {
- ERROR("You need to create the ROM before adding files to it\n");
- return -1;
- }
-
- /* Check that the incoming file exists */
-
- if (access(argv[0], R_OK)) {
- ERROR("File %s does not exist\n", argv[0]);
- return -1;
- }
-
- return fork_tool_and_add(rom, find_tool("rom-mkpayload"), argv[0],
- argv[1], ROMFS_COMPONENT_PAYLOAD, argc - 2,
- argc > 2 ? &argv[2] : NULL);
-}
-
-/* Invoke the rom-mkstage utility */
-
-int add_stage_handler(struct rom *rom, int argc, char **argv)
-{
- if (argc < 2) {
- add_stage_usage();
- return -1;
- }
-
- /* Make sure the ROM exists */
-
- if (!rom_exists(rom)) {
- ERROR("You need to create the ROM before adding files to it\n");
- return -1;
- }
-
- /* Check that the incoming file exists */
-
- if (access(argv[0], R_OK)) {
- ERROR("File %s does not exist\n", argv[0]);
- return -1;
- }
-
- return fork_tool_and_add(rom, find_tool("rom-mkstage"), argv[0],
- argv[1], ROMFS_COMPONENT_STAGE, argc - 2,
- argc > 2 ? &argv[2] : NULL);
-}
+++ /dev/null
-/*
- * romtool
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include "romtool.h"
-
-void bootblock_usage(void)
-{
- printf("bootblock [FILE]\t\tAdd a bootblock to the ROM\n");
-}
-
-int bootblock_handler(struct rom *rom, int argc, char **argv)
-{
- if (argc < 1) {
- bootblock_usage();
- return -1;
- }
-
- return add_bootblock(rom, argv[0]);
-}
+++ /dev/null
-/*
- * romtool
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include "romtool.h"
-
-void create_usage(void)
-{
- printf("create SIZE BOOTBLOCKSIZE [ALIGN] [BOOTBLOCK]\tCreate a ROM file\n");
-}
-
-int create_handler(struct rom *rom, int argc, char **argv)
-{
- int align = 16, size;
- char *bootblock = NULL;
- int bootblocksize;
-
- if (argc < 2) {
- create_usage();
- return -1;
- }
-
- size = get_size(argv[0]);
-
- bootblocksize = get_size(argv[1]);
-
- if (argc == 3) {
- bootblock = argv[2];
- } else if (argc >= 4) {
- align = strtoul(argv[2], NULL, 0);
- bootblock = argv[3];
- }
-
- if (size < bootblocksize) {
- ERROR("Cannot create a rom %d smaller then bootblock size %d\n", size, bootblocksize);
- return -1;
- }
-
- if (align == 0) {
- ERROR("Cannot create with an align size of 0\n");
- return -1;
- }
-
- if (create_rom(rom, rom->name, size, bootblocksize, align))
- return -1;
-
- if (bootblock != NULL)
- return add_bootblock(rom, bootblock);
-
- return 0;
-}
+++ /dev/null
-/*
- * romtool
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#include <ctype.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include "romtool.h"
-
-void delete_usage(void)
-{
- printf("delete [NAME] ...\t\tDelete a component\n");
-}
-
-int delete_handler(struct rom *rom, int argc, char **argv)
-{
- int i;
- int ret = 0;
-
- if (argc < 1) {
- delete_usage();
- return -1;
- }
-
- for (i = 0; i < argc; i++)
- ret |= rom_remove(rom, argv[i]);
-
- return ret;
-}
+++ /dev/null
-/*
- * romtool
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#include <string.h>
-#include "romtool.h"
-
-struct romfs_file *rom_find(struct rom *rom, unsigned int offset)
-{
- while (offset < rom->fssize) {
- struct romfs_file *c =
- (struct romfs_file *)ROM_PTR(rom, offset);
-
- if (!strcmp(c->magic, COMPONENT_MAGIC))
- return c;
-
- offset += ntohl(rom->header->align);
- }
-
- return NULL;
-}
-
-struct romfs_file *rom_find_first(struct rom *rom)
-{
- return rom_find(rom, ntohl(rom->header->offset));
-}
-
-struct romfs_file *rom_find_next(struct rom *rom, struct romfs_file *prev)
-{
- unsigned int offset = ROM_OFFSET(rom, prev);
-
- return rom_find(rom, offset +
- ALIGN(ntohl(prev->offset) + ntohl(prev->len),
- ntohl(rom->header->align)));
-}
-
-struct romfs_file *rom_find_empty(struct rom *rom)
-{
- unsigned int offset = ntohl(rom->header->offset);
- unsigned int ret = ntohl(rom->header->offset);
-
- while (offset < rom->fssize) {
-
- struct romfs_file *c =
- (struct romfs_file *)ROM_PTR(rom, offset);
-
- if (!strcmp(c->magic, COMPONENT_MAGIC)) {
- offset += ALIGN(ntohl(c->offset) + ntohl(c->len),
- ntohl(rom->header->align));
-
- ret = offset;
- } else
- offset += ntohl(rom->header->align);
- }
-
- return (ret < rom->fssize) ?
- (struct romfs_file *)ROM_PTR(rom, ret) : NULL;
-}
-
-struct romfs_file *rom_find_by_name(struct rom *rom, const char *name)
-{
- struct romfs_file *c = rom_find_first(rom);
-
- while (c) {
- if (!strcmp((char *)ROMFS_NAME(c), name))
- return c;
-
- c = rom_find_next(rom, c);
- }
-
- return NULL;
-}
-
-unsigned int rom_used_space(struct rom *rom)
-{
- struct romfs_file *c = rom_find_first(rom);
- unsigned int ret = 0;
-
- while (c) {
- ret = ROM_OFFSET(rom, c) + ntohl(c->offset) + ntohl(c->len);
- c = rom_find_next(rom, c);
- }
-
- return ret;
-}
-
-int rom_remove(struct rom *rom, const char *name)
-{
- struct romfs_file *c = rom_find_by_name(rom, name);
- struct romfs_file *n;
- int clear;
-
- if (c == NULL) {
- ERROR("Component %s does not exist\n", name);
- return -1;
- }
-
- /* Get the next component - and copy it into the current
- space */
-
- n = rom_find_next(rom, c);
-
- memcpy(c, n, rom->fssize - ROM_OFFSET(rom, n));
-
- clear = ROM_OFFSET(rom, n) - ROM_OFFSET(rom, c);
-
- /* Zero the new space */
- memset(ROM_PTR(rom, rom->fssize - clear), 0, clear);
- return 0;
-}
-
-int rom_add(struct rom *rom, const char *name, void *buffer, int size, int type)
-{
- struct romfs_file *c = rom_find_empty(rom);
- unsigned int offset;
- unsigned int csize;
-
- if (rom_find_by_name(rom, name)) {
- ERROR("Component %s already exists in this rom\n", name);
- return -1;
- }
-
- if (c == NULL) {
- ERROR("There is no more room in this ROM\n");
- return -1;
- }
-
- csize = sizeof(struct romfs_file) + ALIGN(strlen(name), 16) + size;
-
- offset = ROM_OFFSET(rom, c);
-
- if (offset + csize >= rom->fssize) {
- ERROR("There is not enough room in this ROM for this\n");
- ERROR("component. I need %d bytes, only have %d bytes avail\n",
- csize, rom->fssize - offset);
-
- return -1;
- }
-
- strcpy(c->magic, COMPONENT_MAGIC);
-
- csize = sizeof(struct romfs_file) + ALIGN(strlen(name) + 1, 16);
-
- c->len = htonl(size);
- c->offset = htonl(csize);
- c->type = htonl(type);
-
- memset(ROMFS_NAME(c), 0, ALIGN(strlen(name) + 1, 16));
- strcpy((char *)ROMFS_NAME(c), name);
-
- memcpy(((unsigned char *)c) + csize, buffer, size);
- return 0;
-}
+++ /dev/null
-/*
- * romtool
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#include <string.h>
-#include "romtool.h"
-
-void print_usage(void)
-{
- printf("print\t\t\t\tShow the contents of the ROM\n");
-}
-
-int print_handler(struct rom *rom, int argc, char **argv)
-{
- printf("%s: %d kB, bootblocksize %d, romsize %d, offset 0x%x\n", rom->name, rom->size / 1024,
- ntohl(rom->header->bootblocksize), ntohl(rom->header->romsize), ntohl(rom->header->offset));
- printf("Alignment: %d bytes\n\n", ntohl(rom->header->align));
-
- struct romfs_file *c = rom_find_first(rom);
-
- printf("%-30s Offset %-12s Size\n", "Name", "Type");
-
- while (c) {
- char type[12];
-
- switch (htonl(c->type)) {
- case ROMFS_COMPONENT_STAGE:
- strcpy(type, "stage");
- break;
- case ROMFS_COMPONENT_PAYLOAD:
- strcpy(type, "payload");
- break;
- case ROMFS_COMPONENT_OPTIONROM:
- strcpy(type, "optionrom");
- break;
- default:
- sprintf(type, "0x%8.8x", htonl(c->type));
- break;
- }
-
- printf("%-30s 0x%-8x %-12s %d\n", ROMFS_NAME(c),
- ROM_OFFSET(rom, c), type, htonl(c->len));
-
- c = rom_find_next(rom, c);
- }
-
- return 0;
-}
+++ /dev/null
-/*
- * romtool
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#include <ctype.h>
-#include <string.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/mman.h>
-
-#include "romtool.h"
-
-void resize_usage(void)
-{
- printf("resize [SIZE] [ERASEBLOCK]\tResize the ROM\n");
-}
-
-int resize_handler(struct rom *rom, int argc, char **argv)
-{
- unsigned int size, align, offset;
- char null = '\0';
- int bootblocksize = ntohl(rom->header->bootblocksize);
-
- if (argc < 1) {
- resize_usage();
- return -1;
- }
-
- if (rom->fd <= 0) {
- ERROR("ROM file %s does not exist\n", rom->name);
- return -1;
- }
-
- align = ntohl(rom->header->align);
- size = get_size(argv[0]);
-
- if (argc >= 2)
- align = strtoul(argv[1], NULL, 0);
-
- if (size == rom->size && align == ntohl(rom->header->align)) {
- ERROR("New parameters are the same as the old\n");
- return 0;
- }
-
- if (size < bootblocksize) {
- ERROR("The new size is smaller then the bootblock size\n");
- return -1;
- }
-
- /* if the current ROM is too big for the new size, then complain */
-
- if (rom_used_space(rom) > size - bootblocksize) {
- ERROR("The new size is too small for the current ROM\n");
- return -1;
- }
-
- /* Grow the rom if we need to */
-
- if (size > rom->size) {
- munmap(rom->ptr, rom->size);
-
- lseek(rom->fd, size - 1, SEEK_SET);
- write(rom->fd, &null, 1);
-
- rom->ptr = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED,
- rom->fd, 0);
-
- if (rom->ptr == MAP_FAILED) {
- ERROR("Unable to grow the ROM\n");
- return -1;
- }
- }
-
- /* We only have to rewrite the entries if the alignment changed */
-
- if (align != ntohl(rom->header->align)) {
- struct romfs_file *c;
-
- /* The first entry doesn't have to move */
-
- c = rom_find(rom, rom->header->offset);
- offset = rom->header->offset;
-
- while (c) {
- struct romfs_file *n = rom_find_next(rom, c);
- unsigned int next;
-
- if (n == NULL)
- break;
-
- /* Calculate a new location for the entry */
- next =
- ROM_OFFSET(rom,
- c) + ALIGN(ntohl(c->offset) +
- ntohl(c->len), align);
-
- /* Copy the next entry there */
- memmove(ROM_PTR(rom, next), n,
- ntohl(n->offset) + ntohl(n->len));
-
- c = (struct romfs_file *)ROM_PTR(rom, next);
-
- /* If the previous header wasn't overwritten by the change,
- corrupt the header so we don't accidently find it */
-
- if (ROM_OFFSET(rom, n) >
- next + ntohl(c->len) + ntohl(c->offset))
- memset(n->magic, 0, sizeof(n->magic));
- }
- }
-
- /* Copy the bootblock */
-
- memmove(rom->ptr + size - bootblocksize,
- rom->ptr + rom->size - bootblocksize, bootblocksize);
-
- /* Recacluate the location of the header */
-
- offset = ROM_READL(rom, size - 12);
-
- rom->header = (struct romfs_header *)
- ROM_PTR(rom, size - (0xFFFFFFFF - offset) - 1);
-
- /* Put the new values in the header */
- rom->header->romsize = htonl(size);
- rom->header->align = htonl(align);
-
- /* Truncate the file if we have to */
-
- if (size < rom->size) {
- munmap(rom->ptr, rom->size);
-
- rom->ptr = NULL;
-
- if (ftruncate(rom->fd, size)) {
- ERROR("Unable to truncate the ROM\n");
- return -1;
- }
-
- rom->ptr = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED,
- rom->fd, 0);
-
- if (rom->ptr == MAP_FAILED) {
- ERROR("Unable to truncate the ROM\n");
- return -1;
- }
- }
-
- rom->size = size;
- rom->fssize = size - bootblocksize;
-
- return 0;
-}
+++ /dev/null
-/*
- * romtool
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#ifndef _ROMFS_H_
-#define _ROMFS_H_
-
-/** These are standard values for the known compression
- alogrithms that coreboot knows about for stages and
- payloads. Of course, other LAR users can use whatever
- values they want, as long as they understand them. */
-
-#define ROMFS_COMPRESS_NONE 0
-#define ROMFS_COMPRESS_LZMA 1
-#define ROMFS_COMPRESS_NRV2B 2
-
-/** These are standard component types for well known
- components (i.e - those that coreboot needs to consume.
- Users are welcome to use any other value for their
- components */
-
-#define ROMFS_COMPONENT_STAGE 0x10
-#define ROMFS_COMPONENT_PAYLOAD 0x20
-#define ROMFS_COMPONENT_OPTIONROM 0x30
-
-#define ROMFS_COMPONENT_NULL 0xFFFFFFFF
-
-/** this is the master romfs header - it need to be
- located somewhere in the bootblock. Where it
- actually lives is up to coreboot. A pointer to
- this header will live at 0xFFFFFFF4, so we can
- easily find it. */
-
-#define HEADER_MAGIC 0x4F524243
-
-/* this is a version that gives the right answer in any endian-ness */
-#define VERSION1 0x31313131
-
-struct romfs_header {
- unsigned int magic;
- unsigned int version;
- unsigned int romsize;
- unsigned int bootblocksize;
- unsigned int align;
- unsigned int offset;
- unsigned int pad[2];
-} __attribute__ ((packed));
-
-/** This is a component header - every entry in the ROMFS
- will have this header.
-
- This is how the component is arranged in the ROM:
-
- -------------- <- 0
- component header
- -------------- <- sizeof(struct component)
- component name
- -------------- <- offset
- data
- ...
- -------------- <- offset + len
-*/
-
-#define COMPONENT_MAGIC "LARCHIVE"
-
-struct romfs_file {
- char magic[8];
- unsigned int len;
- unsigned int type;
- unsigned int checksum;
- unsigned int offset;
-} __attribute__ ((packed));
-
-/*** Component sub-headers ***/
-
-/* Following are component sub-headers for the "standard"
- component types */
-
-/** This is the sub-header for stage components. Stages are
- loaded by coreboot during the normal boot process */
-
-struct romfs_stage {
- unsigned int compression; /** Compression type */
- unsigned long long entry; /** entry point */
- unsigned long long load; /** Where to load in memory */
- unsigned int len; /** length of data to load */
- unsigned int memlen; /** total length of object in memory */
-} __attribute__ ((packed));
-
-/** this is the sub-header for payload components. Payloads
- are loaded by coreboot at the end of the boot process */
-
-struct romfs_payload_segment {
- unsigned int type;
- unsigned int compression;
- unsigned int offset;
- unsigned long long load_addr;
- unsigned int len;
- unsigned int mem_len;
-} __attribute__ ((packed));
-
-struct romfs_payload {
- struct romfs_payload_segment segments;
-};
-
-#define PAYLOAD_SEGMENT_CODE 0x45444F43
-#define PAYLOAD_SEGMENT_DATA 0x41544144
-#define PAYLOAD_SEGMENT_BSS 0x20535342
-#define PAYLOAD_SEGMENT_PARAMS 0x41524150
-#define PAYLOAD_SEGMENT_ENTRY 0x52544E45
-
-#define ROMFS_NAME(_c) (((unsigned char *) (_c)) + sizeof(struct romfs_file))
-
-#endif
+++ /dev/null
-/*
- * romtool
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-/* v2 compat: First, assumes a 64K bootblock.
- * romtool coreboot.rom create 0x80000 coreboot.strip
- * romtool coreboot.rom add-payload /tmp/filo.elf payload
- * romtool coreboot.rom print
- */
-
-
-#include <string.h>
-#include <unistd.h>
-#include <libgen.h>
-#include <sys/mman.h>
-#include "romtool.h"
-
-extern int create_handler(struct rom *, int, char **);
-extern int bootblock_handler(struct rom *, int, char **);
-extern int print_handler(struct rom *, int, char **);
-extern int add_handler(struct rom *, int, char **);
-extern int delete_handler(struct rom *, int, char **);
-extern int resize_handler(struct rom *, int, char **);
-extern int add_payload_handler(struct rom *, int, char **);
-extern int add_stage_handler(struct rom *, int, char **);
-
-extern void create_usage(void);
-extern void bootblock_usage(void);
-extern void print_usage(void);
-extern void add_usage(void);
-extern void delete_usage(void);
-extern void resize_usage(void);
-extern void add_payload_usage(void);
-extern void add_stage_usage(void);
-
-struct {
- char *command;
- int (*handler) (struct rom *, int, char **);
- void (*help) (void);
-} commands[] = {
- {
- "add", add_handler, add_usage}, {
- "add-payload", add_payload_handler, add_payload_usage}, {
- "add-stage", add_stage_handler, add_stage_usage}, {
- "bootblock", bootblock_handler, bootblock_usage}, {
- "create", create_handler, create_usage}, {
- "delete", delete_handler, delete_usage}, {
- "print", print_handler, print_usage}, {
- "resize", resize_handler, resize_usage}, {
-"", NULL},};
-
-static struct rom rom;
-
-char romtool_bindir[255];
-
-void show_help(void)
-{
- int i;
-
- printf("romtool [OPTION] [[FILE] [COMMAND] [PARAMETERS]...\n");
- printf("Apply COMMANDS with PARAMETERS to FILE. If no COMMAND is\n");
- printf("given, run in interactive mode\n\n");
- printf("OPTIONs:\n");
- printf(" -h\t\tDisplay this help message\n");
- printf(" -C <dir>\tChange to the directory before operating\n\n");
- printf("COMMANDs:\n");
-
- for (i = 0; commands[i].handler != NULL; i++)
- commands[i].help();
-}
-
-int main(int argc, char **argv)
-{
- char *cdir = NULL;
- char *rname;
- char *cmd;
- int ret = -1, i;
-
- strncpy(romtool_bindir, dirname(argv[0]), 254);
-
- while (1) {
- signed ch = getopt(argc, argv, "hC:");
- if (ch == -1)
- break;
- switch (ch) {
- case 'h':
- show_help();
- return -1;
- case 'C':
- cdir = optarg;
- break;
- }
- }
-
- if (optind >= argc) {
- show_help();
- return -1;
- }
-
- if (cdir != NULL && chdir(cdir)) {
- ERROR("Unable to switch to %s: %m\n", cdir);
- return -1;
- }
-
- rname = argv[optind];
- cmd = optind + 1 < argc ? argv[optind + 1] : NULL;
-
- /* Open the ROM (if it exists) */
- rom.name = (unsigned char *)strdup(rname);
-
- if (!access(rname, F_OK)) {
- if (open_rom(&rom, rname)) {
- ERROR("Problem while reading the ROM\n");
- return -1;
- }
- }
-
- if (cmd) {
- /* Process the incoming comand */
-
- for (i = 0; commands[i].handler != NULL; i++) {
- if (!strcmp(commands[i].command, cmd)) {
- ret = commands[i].handler(&rom,
- argc - 3, &argv[3]);
- goto leave;
- }
- }
-
- ERROR("Command %s not valid\n", cmd);
- } else {
- printf("Interactive mode not ready yet!\n");
- }
-
-leave:
- if (rom.ptr != NULL && rom.ptr != MAP_FAILED)
- munmap(rom.ptr, rom.size);
-
- if (rom.fd > 0)
- close(rom.fd);
-
- return ret;
-}
+++ /dev/null
-/*
- * romtool
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#ifndef _ROMTOOL_H_
-#define _ROMTOOL_H_
-
-#include <stdio.h>
-#include <arpa/inet.h>
-#include "romfs.h"
-
-/* Definitions */
-
-/* Structures */
-
-struct rom {
- unsigned char *name;
- unsigned char *ptr;
-
- int fd;
- int size;
- int fssize;
-
- struct romfs_header *header;
-};
-
-/* Macros */
-
-#define ROM_OFFSET(_r, _c) ((unsigned int) ((unsigned char *) (_c) - (_r)->ptr))
-
-#define ROM_PTR(_r, _o) ((_r)->ptr + (_o))
-#define ROM_WRITEL(_r, _o, _v) do { *((unsigned int *) ROM_PTR((_r), (_o))) = (_v); } while(0)
-#define ROM_READL(_r, _o) *((unsigned int *) (ROM_PTR((_r), (_o))))
-
-#define ERROR(err, args...) fprintf(stderr, "(romtool) E: " err, ##args)
-#define WARN(err, args...) fprintf(stderr, "(romtool) W: " err, ##args)
-#define VERBOSE(str, args...) printf(str, ##args)
-
-#define ALIGN(_v, _a) ( ( (_v) + ( (_a) - 1 ) ) & ~( (_a) - 1 ) )
-
-/* Function prototypes */
-
-/* util.c */
-int open_rom(struct rom *rom, const char *filename);
-int create_rom(struct rom *rom, const unsigned char *filename, int size,
- int bootblocksize, int align);
-int size_and_open(const char *filename, unsigned int *size);
-int copy_from_fd(int fd, void *ptr, int size);
-int get_size(const char *size);
-int add_bootblock(struct rom *rom, const char *filename);
-
-/* fs.c */
-
-struct romfs_file *rom_find(struct rom *rom, unsigned int offset);
-struct romfs_file *rom_find_first(struct rom *);
-struct romfs_file *rom_find_next(struct rom *, struct romfs_file *);
-int rom_add(struct rom *rom, const char *name, void *, int size, int type);
-int rom_remove(struct rom *rom, const char *name);
-unsigned int rom_used_space(struct rom *rom);
-int rom_exists(struct rom *rom);
-
-#endif
+++ /dev/null
-tobj ?= $(shell pwd)
-tsrc ?= $(shell pwd)
-
-TARGETS += $(tobj)/rom-mkstage $(tobj)/rom-mkpayload
-
-tools: $(tobj)/rom-mkstage $(tobj)/rom-mkpayload
-
-include $(tsrc)/lzma/Makefile
-
-COMMON = common.o compress.o $(LZMA_OBJ)
-
-$(tobj)/rom-mkstage: $(tobj)/rom-mkstage.o $(patsubst %,$(tobj)/%,$(COMMON))
- $(CXX) $(CFLAGS) -o $@ $^
-
-$(tobj)/rom-mkpayload: $(tobj)/rom-mkpayload.o $(patsubst %,$(tobj)/%,$(COMMON))
- $(CXX) $(CFLAGS) -o $@ $^
-
-$(tobj)/%.o: %.c
- $(CC) $(CFLAGS) -c -o $@ $<
-
-tools-clean:
- rm -f $(tobj)/rom-mkpayload.o $(tobj)/rom-mkstage.o $(patsubst %,$(tobj)/%,$(COMMON))
- rm -f $(tobj)/rom-mkpayload $(tobj)/rom-mkstage
-
+++ /dev/null
-/*
- * romtool
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#include <stdio.h>
-#include "elf.h"
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/stat.h>
-
-#include "common.h"
-
-#define BLOCKSIZE (1024 * 16)
-
-void file_write_from_buffer(int fd, unsigned char *buffer, int size)
-{
- unsigned char *ptr = buffer;
-
- while (size) {
- int ret = write(fd, ptr, size);
-
- if (ret == -1)
- break;
-
- size -= ret;
- ptr += ret;
- }
-}
-
-unsigned char *file_read_to_buffer(int fd, int *fsize)
-{
- unsigned char *buffer = malloc(BLOCKSIZE);
- unsigned char *ptr = buffer;
-
- int bsize = BLOCKSIZE;
- int remain = BLOCKSIZE;
- int size = 0;
- int ret;
-
- if (buffer == NULL)
- return NULL;
-
- while (1) {
- ret = read(fd, ptr, remain);
-
- if (ret <= 0)
- break;
-
- remain -= ret;
- ptr += ret;
- size += ret;
-
- /* Allocate more memory */
-
- if (remain == 0) {
- buffer = realloc(buffer, bsize + BLOCKSIZE);
-
- if (buffer == NULL)
- return NULL;
-
- ptr = buffer + size;
-
- bsize += BLOCKSIZE;
- remain = BLOCKSIZE;
- }
- }
-
- if (ret == 0) {
- *fsize = size;
- return buffer;
- }
-
- *fsize = 0;
- free(buffer);
- return NULL;
-}
-
-unsigned char *file_read(const char *filename, int *fsize)
-{
- int fd = open(filename, O_RDONLY);
- unsigned char *buffer;
-
- if (fd == -1)
- return NULL;
-
- buffer = file_read_to_buffer(fd, fsize);
- close(fd);
- return buffer;
-}
-
-void file_write(const char *filename, unsigned char *buffer, int size)
-{
- int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC,
- S_IRUSR | S_IWUSR);
-
- if (fd == -1) {
- fprintf(stderr, "E: Could not create %s: %m\n", filename);
- return;
- }
-
- file_write_from_buffer(fd, buffer, size);
- close(fd);
-}
-
-int iself(unsigned char *input)
-{
- Elf32_Ehdr *ehdr = (Elf32_Ehdr *) input;
- return !memcmp(ehdr->e_ident, ELFMAG, 4);
-}
+++ /dev/null
-/*
- * romtool
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#ifndef _COMMON_H_
-#define _COMMON_H_
-
-int iself(unsigned char *input);
-unsigned char *file_read(const char *filename, int *fsize);
-void file_write(const char *filename, unsigned char *buffer, int size);
-unsigned char *file_read_to_buffer(int fd, int *fsize);
-void file_write_from_buffer(int fd, unsigned char *buffer, int size);
-
-/* compress.c */
-
-void lzma_compress(char *in, int in_len, char *out, int *out_len);
-void none_compress(char *in, int in_len, char *out, int *out_len);
-
-#endif
+++ /dev/null
-/*
- * romtool
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#include <string.h>
-
-extern void do_lzma_compress(char *in, int in_len, char *out, int *out_len);
-
-void lzma_compress(char *in, int in_len, char *out, int *out_len)
-{
- do_lzma_compress(in, in_len, out, out_len);
-}
-
-void none_compress(char *in, int in_len, char *out, int *out_len)
-{
- memcpy(out, in, in_len);
- *out_len = in_len;
-}
+++ /dev/null
-/* This file defines standard ELF types, structures, and macros.
- Copyright (C) 1995-2003,2004,2005,2006,2007 Free Software Foundation, Inc.
- This file is part of the GNU C Library.
-
- The GNU C Library 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.
-
- The GNU C Library 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 the GNU C Library; if not, write to the Free
- Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
- 02111-1307 USA. */
-
-#ifndef _ELF_H
-#define _ELF_H 1
-
-#include <stdint.h>
-
-/* Type for a 16-bit quantity. */
-typedef uint16_t Elf32_Half;
-typedef uint16_t Elf64_Half;
-
-/* Types for signed and unsigned 32-bit quantities. */
-typedef uint32_t Elf32_Word;
-typedef int32_t Elf32_Sword;
-typedef uint32_t Elf64_Word;
-typedef int32_t Elf64_Sword;
-
-/* Types for signed and unsigned 64-bit quantities. */
-typedef uint64_t Elf32_Xword;
-typedef int64_t Elf32_Sxword;
-typedef uint64_t Elf64_Xword;
-typedef int64_t Elf64_Sxword;
-
-/* Type of addresses. */
-typedef uint32_t Elf32_Addr;
-typedef uint64_t Elf64_Addr;
-
-/* Type of file offsets. */
-typedef uint32_t Elf32_Off;
-typedef uint64_t Elf64_Off;
-
-/* Type for section indices, which are 16-bit quantities. */
-typedef uint16_t Elf32_Section;
-typedef uint16_t Elf64_Section;
-
-/* Type for version symbol information. */
-typedef Elf32_Half Elf32_Versym;
-typedef Elf64_Half Elf64_Versym;
-
-
-/* The ELF file header. This appears at the start of every ELF file. */
-
-#define EI_NIDENT (16)
-
-typedef struct
-{
- unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */
- Elf32_Half e_type; /* Object file type */
- Elf32_Half e_machine; /* Architecture */
- Elf32_Word e_version; /* Object file version */
- Elf32_Addr e_entry; /* Entry point virtual address */
- Elf32_Off e_phoff; /* Program header table file offset */
- Elf32_Off e_shoff; /* Section header table file offset */
- Elf32_Word e_flags; /* Processor-specific flags */
- Elf32_Half e_ehsize; /* ELF header size in bytes */
- Elf32_Half e_phentsize; /* Program header table entry size */
- Elf32_Half e_phnum; /* Program header table entry count */
- Elf32_Half e_shentsize; /* Section header table entry size */
- Elf32_Half e_shnum; /* Section header table entry count */
- Elf32_Half e_shstrndx; /* Section header string table index */
-} Elf32_Ehdr;
-
-typedef struct
-{
- unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */
- Elf64_Half e_type; /* Object file type */
- Elf64_Half e_machine; /* Architecture */
- Elf64_Word e_version; /* Object file 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; /* Processor-specific flags */
- Elf64_Half e_ehsize; /* ELF header size in bytes */
- Elf64_Half e_phentsize; /* Program header table entry size */
- Elf64_Half e_phnum; /* Program header table entry count */
- Elf64_Half e_shentsize; /* Section header table entry size */
- Elf64_Half e_shnum; /* Section header table entry count */
- Elf64_Half e_shstrndx; /* Section header string table index */
-} Elf64_Ehdr;
-
-/* Fields in the e_ident array. The EI_* macros are indices into the
- array. The macros under each EI_* macro are the values the byte
- may have. */
-
-#define EI_MAG0 0 /* File identification byte 0 index */
-#define ELFMAG0 0x7f /* Magic number byte 0 */
-
-#define EI_MAG1 1 /* File identification byte 1 index */
-#define ELFMAG1 'E' /* Magic number byte 1 */
-
-#define EI_MAG2 2 /* File identification byte 2 index */
-#define ELFMAG2 'L' /* Magic number byte 2 */
-
-#define EI_MAG3 3 /* File identification byte 3 index */
-#define ELFMAG3 'F' /* Magic number byte 3 */
-
-/* Conglomeration of the identification bytes, for easy testing as a word. */
-#define ELFMAG "\177ELF"
-#define SELFMAG 4
-
-#define EI_CLASS 4 /* File class byte index */
-#define ELFCLASSNONE 0 /* Invalid class */
-#define ELFCLASS32 1 /* 32-bit objects */
-#define ELFCLASS64 2 /* 64-bit objects */
-#define ELFCLASSNUM 3
-
-#define EI_DATA 5 /* Data encoding byte index */
-#define ELFDATANONE 0 /* Invalid data encoding */
-#define ELFDATA2LSB 1 /* 2's complement, little endian */
-#define ELFDATA2MSB 2 /* 2's complement, big endian */
-#define ELFDATANUM 3
-
-#define EI_VERSION 6 /* File version byte index */
- /* Value must be EV_CURRENT */
-
-#define EI_OSABI 7 /* OS ABI identification */
-#define ELFOSABI_NONE 0 /* UNIX System V ABI */
-#define ELFOSABI_SYSV 0 /* Alias. */
-#define ELFOSABI_HPUX 1 /* HP-UX */
-#define ELFOSABI_NETBSD 2 /* NetBSD. */
-#define ELFOSABI_LINUX 3 /* Linux. */
-#define ELFOSABI_SOLARIS 6 /* Sun Solaris. */
-#define ELFOSABI_AIX 7 /* IBM AIX. */
-#define ELFOSABI_IRIX 8 /* SGI Irix. */
-#define ELFOSABI_FREEBSD 9 /* FreeBSD. */
-#define ELFOSABI_TRU64 10 /* Compaq TRU64 UNIX. */
-#define ELFOSABI_MODESTO 11 /* Novell Modesto. */
-#define ELFOSABI_OPENBSD 12 /* OpenBSD. */
-#define ELFOSABI_ARM 97 /* ARM */
-#define ELFOSABI_STANDALONE 255 /* Standalone (embedded) application */
-
-#define EI_ABIVERSION 8 /* ABI version */
-
-#define EI_PAD 9 /* Byte index of padding bytes */
-
-/* Legal values for e_type (object file type). */
-
-#define ET_NONE 0 /* No file type */
-#define ET_REL 1 /* Relocatable file */
-#define ET_EXEC 2 /* Executable file */
-#define ET_DYN 3 /* Shared object file */
-#define ET_CORE 4 /* Core file */
-#define ET_NUM 5 /* Number of defined types */
-#define ET_LOOS 0xfe00 /* OS-specific range start */
-#define ET_HIOS 0xfeff /* OS-specific range end */
-#define ET_LOPROC 0xff00 /* Processor-specific range start */
-#define ET_HIPROC 0xffff /* Processor-specific range end */
-
-/* Legal values for e_machine (architecture). */
-
-#define EM_NONE 0 /* No machine */
-#define EM_M32 1 /* AT&T WE 32100 */
-#define EM_SPARC 2 /* SUN SPARC */
-#define EM_386 3 /* Intel 80386 */
-#define EM_68K 4 /* Motorola m68k family */
-#define EM_88K 5 /* Motorola m88k family */
-#define EM_860 7 /* Intel 80860 */
-#define EM_MIPS 8 /* MIPS R3000 big-endian */
-#define EM_S370 9 /* IBM System/370 */
-#define EM_MIPS_RS3_LE 10 /* MIPS R3000 little-endian */
-
-#define EM_PARISC 15 /* HPPA */
-#define EM_VPP500 17 /* Fujitsu VPP500 */
-#define EM_SPARC32PLUS 18 /* Sun's "v8plus" */
-#define EM_960 19 /* Intel 80960 */
-#define EM_PPC 20 /* PowerPC */
-#define EM_PPC64 21 /* PowerPC 64-bit */
-#define EM_S390 22 /* IBM S390 */
-
-#define EM_V800 36 /* NEC V800 series */
-#define EM_FR20 37 /* Fujitsu FR20 */
-#define EM_RH32 38 /* TRW RH-32 */
-#define EM_RCE 39 /* Motorola RCE */
-#define EM_ARM 40 /* ARM */
-#define EM_FAKE_ALPHA 41 /* Digital Alpha */
-#define EM_SH 42 /* Hitachi SH */
-#define EM_SPARCV9 43 /* SPARC v9 64-bit */
-#define EM_TRICORE 44 /* Siemens Tricore */
-#define EM_ARC 45 /* Argonaut RISC Core */
-#define EM_H8_300 46 /* Hitachi H8/300 */
-#define EM_H8_300H 47 /* Hitachi H8/300H */
-#define EM_H8S 48 /* Hitachi H8S */
-#define EM_H8_500 49 /* Hitachi H8/500 */
-#define EM_IA_64 50 /* Intel Merced */
-#define EM_MIPS_X 51 /* Stanford MIPS-X */
-#define EM_COLDFIRE 52 /* Motorola Coldfire */
-#define EM_68HC12 53 /* Motorola M68HC12 */
-#define EM_MMA 54 /* Fujitsu MMA Multimedia Accelerator*/
-#define EM_PCP 55 /* Siemens PCP */
-#define EM_NCPU 56 /* Sony nCPU embeeded RISC */
-#define EM_NDR1 57 /* Denso NDR1 microprocessor */
-#define EM_STARCORE 58 /* Motorola Start*Core processor */
-#define EM_ME16 59 /* Toyota ME16 processor */
-#define EM_ST100 60 /* STMicroelectronic ST100 processor */
-#define EM_TINYJ 61 /* Advanced Logic Corp. Tinyj emb.fam*/
-#define EM_X86_64 62 /* AMD x86-64 architecture */
-#define EM_PDSP 63 /* Sony DSP Processor */
-
-#define EM_FX66 66 /* Siemens FX66 microcontroller */
-#define EM_ST9PLUS 67 /* STMicroelectronics ST9+ 8/16 mc */
-#define EM_ST7 68 /* STmicroelectronics ST7 8 bit mc */
-#define EM_68HC16 69 /* Motorola MC68HC16 microcontroller */
-#define EM_68HC11 70 /* Motorola MC68HC11 microcontroller */
-#define EM_68HC08 71 /* Motorola MC68HC08 microcontroller */
-#define EM_68HC05 72 /* Motorola MC68HC05 microcontroller */
-#define EM_SVX 73 /* Silicon Graphics SVx */
-#define EM_ST19 74 /* STMicroelectronics ST19 8 bit mc */
-#define EM_VAX 75 /* Digital VAX */
-#define EM_CRIS 76 /* Axis Communications 32-bit embedded processor */
-#define EM_JAVELIN 77 /* Infineon Technologies 32-bit embedded processor */
-#define EM_FIREPATH 78 /* Element 14 64-bit DSP Processor */
-#define EM_ZSP 79 /* LSI Logic 16-bit DSP Processor */
-#define EM_MMIX 80 /* Donald Knuth's educational 64-bit processor */
-#define EM_HUANY 81 /* Harvard University machine-independent object files */
-#define EM_PRISM 82 /* SiTera Prism */
-#define EM_AVR 83 /* Atmel AVR 8-bit microcontroller */
-#define EM_FR30 84 /* Fujitsu FR30 */
-#define EM_D10V 85 /* Mitsubishi D10V */
-#define EM_D30V 86 /* Mitsubishi D30V */
-#define EM_V850 87 /* NEC v850 */
-#define EM_M32R 88 /* Mitsubishi M32R */
-#define EM_MN10300 89 /* Matsushita MN10300 */
-#define EM_MN10200 90 /* Matsushita MN10200 */
-#define EM_PJ 91 /* picoJava */
-#define EM_OPENRISC 92 /* OpenRISC 32-bit embedded processor */
-#define EM_ARC_A5 93 /* ARC Cores Tangent-A5 */
-#define EM_XTENSA 94 /* Tensilica Xtensa Architecture */
-#define EM_NUM 95
-
-/* If it is necessary to assign new unofficial EM_* values, please
- pick large random numbers (0x8523, 0xa7f2, etc.) to minimize the
- chances of collision with official or non-GNU unofficial values. */
-
-#define EM_ALPHA 0x9026
-
-/* Legal values for e_version (version). */
-
-#define EV_NONE 0 /* Invalid ELF version */
-#define EV_CURRENT 1 /* Current version */
-#define EV_NUM 2
-
-/* Section header. */
-
-typedef struct
-{
- Elf32_Word sh_name; /* Section name (string tbl index) */
- Elf32_Word sh_type; /* Section type */
- Elf32_Word sh_flags; /* Section flags */
- Elf32_Addr sh_addr; /* Section virtual addr at execution */
- Elf32_Off sh_offset; /* Section file offset */
- Elf32_Word sh_size; /* Section size in bytes */
- Elf32_Word sh_link; /* Link to another section */
- Elf32_Word sh_info; /* Additional section information */
- Elf32_Word sh_addralign; /* Section alignment */
- Elf32_Word sh_entsize; /* Entry size if section holds table */
-} Elf32_Shdr;
-
-typedef struct
-{
- Elf64_Word sh_name; /* Section name (string tbl index) */
- Elf64_Word sh_type; /* Section type */
- Elf64_Xword sh_flags; /* Section flags */
- Elf64_Addr sh_addr; /* Section virtual addr at execution */
- Elf64_Off sh_offset; /* Section file offset */
- Elf64_Xword sh_size; /* Section size in bytes */
- Elf64_Word sh_link; /* Link to 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;
-
-/* Special section indices. */
-
-#define SHN_UNDEF 0 /* Undefined section */
-#define SHN_LORESERVE 0xff00 /* Start of reserved indices */
-#define SHN_LOPROC 0xff00 /* Start of processor-specific */
-#define SHN_BEFORE 0xff00 /* Order section before all others
- (Solaris). */
-#define SHN_AFTER 0xff01 /* Order section after all others
- (Solaris). */
-#define SHN_HIPROC 0xff1f /* End of processor-specific */
-#define SHN_LOOS 0xff20 /* Start of OS-specific */
-#define SHN_HIOS 0xff3f /* End of OS-specific */
-#define SHN_ABS 0xfff1 /* Associated symbol is absolute */
-#define SHN_COMMON 0xfff2 /* Associated symbol is common */
-#define SHN_XINDEX 0xffff /* Index is in extra table. */
-#define SHN_HIRESERVE 0xffff /* End of reserved indices */
-
-/* Legal values for sh_type (section type). */
-
-#define SHT_NULL 0 /* Section header table entry unused */
-#define SHT_PROGBITS 1 /* Program data */
-#define SHT_SYMTAB 2 /* Symbol table */
-#define SHT_STRTAB 3 /* String table */
-#define SHT_RELA 4 /* Relocation entries with addends */
-#define SHT_HASH 5 /* Symbol hash table */
-#define SHT_DYNAMIC 6 /* Dynamic linking information */
-#define SHT_NOTE 7 /* Notes */
-#define SHT_NOBITS 8 /* Program space with no data (bss) */
-#define SHT_REL 9 /* Relocation entries, no addends */
-#define SHT_SHLIB 10 /* Reserved */
-#define SHT_DYNSYM 11 /* Dynamic linker symbol table */
-#define SHT_INIT_ARRAY 14 /* Array of constructors */
-#define SHT_FINI_ARRAY 15 /* Array of destructors */
-#define SHT_PREINIT_ARRAY 16 /* Array of pre-constructors */
-#define SHT_GROUP 17 /* Section group */
-#define SHT_SYMTAB_SHNDX 18 /* Extended section indeces */
-#define SHT_NUM 19 /* Number of defined types. */
-#define SHT_LOOS 0x60000000 /* Start OS-specific. */
-#define SHT_GNU_HASH 0x6ffffff6 /* GNU-style hash table. */
-#define SHT_GNU_LIBLIST 0x6ffffff7 /* Prelink library list */
-#define SHT_CHECKSUM 0x6ffffff8 /* Checksum for DSO content. */
-#define SHT_LOSUNW 0x6ffffffa /* Sun-specific low bound. */
-#define SHT_SUNW_move 0x6ffffffa
-#define SHT_SUNW_COMDAT 0x6ffffffb
-#define SHT_SUNW_syminfo 0x6ffffffc
-#define SHT_GNU_verdef 0x6ffffffd /* Version definition section. */
-#define SHT_GNU_verneed 0x6ffffffe /* Version needs section. */
-#define SHT_GNU_versym 0x6fffffff /* Version symbol table. */
-#define SHT_HISUNW 0x6fffffff /* Sun-specific high bound. */
-#define SHT_HIOS 0x6fffffff /* End OS-specific type */
-#define SHT_LOPROC 0x70000000 /* Start of processor-specific */
-#define SHT_HIPROC 0x7fffffff /* End of processor-specific */
-#define SHT_LOUSER 0x80000000 /* Start of application-specific */
-#define SHT_HIUSER 0x8fffffff /* End of application-specific */
-
-/* Legal values for sh_flags (section flags). */
-
-#define SHF_WRITE (1 << 0) /* Writable */
-#define SHF_ALLOC (1 << 1) /* Occupies memory during execution */
-#define SHF_EXECINSTR (1 << 2) /* Executable */
-#define SHF_MERGE (1 << 4) /* Might be merged */
-#define SHF_STRINGS (1 << 5) /* Contains nul-terminated strings */
-#define SHF_INFO_LINK (1 << 6) /* `sh_info' contains SHT index */
-#define SHF_LINK_ORDER (1 << 7) /* Preserve order after combining */
-#define SHF_OS_NONCONFORMING (1 << 8) /* Non-standard OS specific handling
- required */
-#define SHF_GROUP (1 << 9) /* Section is member of a group. */
-#define SHF_TLS (1 << 10) /* Section hold thread-local data. */
-#define SHF_MASKOS 0x0ff00000 /* OS-specific. */
-#define SHF_MASKPROC 0xf0000000 /* Processor-specific */
-#define SHF_ORDERED (1 << 30) /* Special ordering requirement
- (Solaris). */
-#define SHF_EXCLUDE (1 << 31) /* Section is excluded unless
- referenced or allocated (Solaris).*/
-
-/* Section group handling. */
-#define GRP_COMDAT 0x1 /* Mark group as COMDAT. */
-
-/* Symbol table entry. */
-
-typedef struct
-{
- Elf32_Word st_name; /* Symbol name (string tbl index) */
- Elf32_Addr st_value; /* Symbol value */
- Elf32_Word st_size; /* Symbol size */
- unsigned char st_info; /* Symbol type and binding */
- unsigned char st_other; /* Symbol visibility */
- Elf32_Section st_shndx; /* Section index */
-} Elf32_Sym;
-
-typedef struct
-{
- Elf64_Word st_name; /* Symbol name (string tbl index) */
- unsigned char st_info; /* Symbol type and binding */
- unsigned char st_other; /* Symbol visibility */
- Elf64_Section st_shndx; /* Section index */
- Elf64_Addr st_value; /* Symbol value */
- Elf64_Xword st_size; /* Symbol size */
-} Elf64_Sym;
-
-/* The syminfo section if available contains additional information about
- every dynamic symbol. */
-
-typedef struct
-{
- Elf32_Half si_boundto; /* Direct bindings, symbol bound to */
- Elf32_Half si_flags; /* Per symbol flags */
-} Elf32_Syminfo;
-
-typedef struct
-{
- Elf64_Half si_boundto; /* Direct bindings, symbol bound to */
- Elf64_Half si_flags; /* Per symbol flags */
-} Elf64_Syminfo;
-
-/* Possible values for si_boundto. */
-#define SYMINFO_BT_SELF 0xffff /* Symbol bound to self */
-#define SYMINFO_BT_PARENT 0xfffe /* Symbol bound to parent */
-#define SYMINFO_BT_LOWRESERVE 0xff00 /* Beginning of reserved entries */
-
-/* Possible bitmasks for si_flags. */
-#define SYMINFO_FLG_DIRECT 0x0001 /* Direct bound symbol */
-#define SYMINFO_FLG_PASSTHRU 0x0002 /* Pass-thru symbol for translator */
-#define SYMINFO_FLG_COPY 0x0004 /* Symbol is a copy-reloc */
-#define SYMINFO_FLG_LAZYLOAD 0x0008 /* Symbol bound to object to be lazy
- loaded */
-/* Syminfo version values. */
-#define SYMINFO_NONE 0
-#define SYMINFO_CURRENT 1
-#define SYMINFO_NUM 2
-
-
-/* How to extract and insert information held in the st_info field. */
-
-#define ELF32_ST_BIND(val) (((unsigned char) (val)) >> 4)
-#define ELF32_ST_TYPE(val) ((val) & 0xf)
-#define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
-
-/* Both Elf32_Sym and Elf64_Sym use the same one-byte st_info field. */
-#define ELF64_ST_BIND(val) ELF32_ST_BIND (val)
-#define ELF64_ST_TYPE(val) ELF32_ST_TYPE (val)
-#define ELF64_ST_INFO(bind, type) ELF32_ST_INFO ((bind), (type))
-
-/* Legal values for ST_BIND subfield of st_info (symbol binding). */
-
-#define STB_LOCAL 0 /* Local symbol */
-#define STB_GLOBAL 1 /* Global symbol */
-#define STB_WEAK 2 /* Weak symbol */
-#define STB_NUM 3 /* Number of defined types. */
-#define STB_LOOS 10 /* Start of OS-specific */
-#define STB_HIOS 12 /* End of OS-specific */
-#define STB_LOPROC 13 /* Start of processor-specific */
-#define STB_HIPROC 15 /* End of processor-specific */
-
-/* Legal values for ST_TYPE subfield of st_info (symbol type). */
-
-#define STT_NOTYPE 0 /* Symbol type is unspecified */
-#define STT_OBJECT 1 /* Symbol is a data object */
-#define STT_FUNC 2 /* Symbol is a code object */
-#define STT_SECTION 3 /* Symbol associated with a section */
-#define STT_FILE 4 /* Symbol's name is file name */
-#define STT_COMMON 5 /* Symbol is a common data object */
-#define STT_TLS 6 /* Symbol is thread-local data object*/
-#define STT_NUM 7 /* Number of defined types. */
-#define STT_LOOS 10 /* Start of OS-specific */
-#define STT_HIOS 12 /* End of OS-specific */
-#define STT_LOPROC 13 /* Start of processor-specific */
-#define STT_HIPROC 15 /* End of processor-specific */
-
-
-/* Symbol table indices are found in the hash buckets and chain table
- of a symbol hash table section. This special index value indicates
- the end of a chain, meaning no further symbols are found in that bucket. */
-
-#define STN_UNDEF 0 /* End of a chain. */
-
-
-/* How to extract and insert information held in the st_other field. */
-
-#define ELF32_ST_VISIBILITY(o) ((o) & 0x03)
-
-/* For ELF64 the definitions are the same. */
-#define ELF64_ST_VISIBILITY(o) ELF32_ST_VISIBILITY (o)
-
-/* Symbol visibility specification encoded in the st_other field. */
-#define STV_DEFAULT 0 /* Default symbol visibility rules */
-#define STV_INTERNAL 1 /* Processor specific hidden class */
-#define STV_HIDDEN 2 /* Sym unavailable in other modules */
-#define STV_PROTECTED 3 /* Not preemptible, not exported */
-
-
-/* Relocation table entry without addend (in section of type SHT_REL). */
-
-typedef struct
-{
- Elf32_Addr r_offset; /* Address */
- Elf32_Word r_info; /* Relocation type and symbol index */
-} Elf32_Rel;
-
-/* I have seen two different definitions of the Elf64_Rel and
- Elf64_Rela structures, so we'll leave them out until Novell (or
- whoever) gets their act together. */
-/* The following, at least, is used on Sparc v9, MIPS, and Alpha. */
-
-typedef struct
-{
- Elf64_Addr r_offset; /* Address */
- Elf64_Xword r_info; /* Relocation type and symbol index */
-} Elf64_Rel;
-
-/* Relocation table entry with addend (in section of type SHT_RELA). */
-
-typedef struct
-{
- Elf32_Addr r_offset; /* Address */
- Elf32_Word r_info; /* Relocation type and symbol index */
- Elf32_Sword r_addend; /* Addend */
-} Elf32_Rela;
-
-typedef struct
-{
- Elf64_Addr r_offset; /* Address */
- Elf64_Xword r_info; /* Relocation type and symbol index */
- Elf64_Sxword r_addend; /* Addend */
-} Elf64_Rela;
-
-/* How to extract and insert information held in the r_info field. */
-
-#define ELF32_R_SYM(val) ((val) >> 8)
-#define ELF32_R_TYPE(val) ((val) & 0xff)
-#define ELF32_R_INFO(sym, type) (((sym) << 8) + ((type) & 0xff))
-
-#define ELF64_R_SYM(i) ((i) >> 32)
-#define ELF64_R_TYPE(i) ((i) & 0xffffffff)
-#define ELF64_R_INFO(sym,type) ((((Elf64_Xword) (sym)) << 32) + (type))
-
-/* Program segment header. */
-
-typedef struct
-{
- Elf32_Word p_type; /* Segment type */
- Elf32_Off p_offset; /* Segment file offset */
- Elf32_Addr p_vaddr; /* Segment virtual address */
- Elf32_Addr p_paddr; /* Segment physical address */
- Elf32_Word p_filesz; /* Segment size in file */
- Elf32_Word p_memsz; /* Segment size in memory */
- Elf32_Word p_flags; /* Segment flags */
- Elf32_Word p_align; /* Segment alignment */
-} Elf32_Phdr;
-
-typedef struct
-{
- Elf64_Word p_type; /* Segment type */
- Elf64_Word p_flags; /* Segment 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 */
-} Elf64_Phdr;
-
-/* Legal values for p_type (segment type). */
-
-#define PT_NULL 0 /* Program header table entry unused */
-#define PT_LOAD 1 /* Loadable program segment */
-#define PT_DYNAMIC 2 /* Dynamic linking information */
-#define PT_INTERP 3 /* Program interpreter */
-#define PT_NOTE 4 /* Auxiliary information */
-#define PT_SHLIB 5 /* Reserved */
-#define PT_PHDR 6 /* Entry for header table itself */
-#define PT_TLS 7 /* Thread-local storage segment */
-#define PT_NUM 8 /* Number of defined types */
-#define PT_LOOS 0x60000000 /* Start of OS-specific */
-#define PT_GNU_EH_FRAME 0x6474e550 /* GCC .eh_frame_hdr segment */
-#define PT_GNU_STACK 0x6474e551 /* Indicates stack executability */
-#define PT_GNU_RELRO 0x6474e552 /* Read-only after relocation */
-#define PT_LOSUNW 0x6ffffffa
-#define PT_SUNWBSS 0x6ffffffa /* Sun Specific segment */
-#define PT_SUNWSTACK 0x6ffffffb /* Stack segment */
-#define PT_HISUNW 0x6fffffff
-#define PT_HIOS 0x6fffffff /* End of OS-specific */
-#define PT_LOPROC 0x70000000 /* Start of processor-specific */
-#define PT_HIPROC 0x7fffffff /* End of processor-specific */
-
-/* Legal values for p_flags (segment flags). */
-
-#define PF_X (1 << 0) /* Segment is executable */
-#define PF_W (1 << 1) /* Segment is writable */
-#define PF_R (1 << 2) /* Segment is readable */
-#define PF_MASKOS 0x0ff00000 /* OS-specific */
-#define PF_MASKPROC 0xf0000000 /* Processor-specific */
-
-/* Legal values for note segment descriptor types for core files. */
-
-#define NT_PRSTATUS 1 /* Contains copy of prstatus struct */
-#define NT_FPREGSET 2 /* Contains copy of fpregset struct */
-#define NT_PRPSINFO 3 /* Contains copy of prpsinfo struct */
-#define NT_PRXREG 4 /* Contains copy of prxregset struct */
-#define NT_TASKSTRUCT 4 /* Contains copy of task structure */
-#define NT_PLATFORM 5 /* String from sysinfo(SI_PLATFORM) */
-#define NT_AUXV 6 /* Contains copy of auxv array */
-#define NT_GWINDOWS 7 /* Contains copy of gwindows struct */
-#define NT_ASRS 8 /* Contains copy of asrset struct */
-#define NT_PSTATUS 10 /* Contains copy of pstatus struct */
-#define NT_PSINFO 13 /* Contains copy of psinfo struct */
-#define NT_PRCRED 14 /* Contains copy of prcred struct */
-#define NT_UTSNAME 15 /* Contains copy of utsname struct */
-#define NT_LWPSTATUS 16 /* Contains copy of lwpstatus struct */
-#define NT_LWPSINFO 17 /* Contains copy of lwpinfo struct */
-#define NT_PRFPXREG 20 /* Contains copy of fprxregset struct */
-#define NT_PRXFPREG 0x46e62b7f /* Contains copy of user_fxsr_struct */
-
-/* Legal values for the note segment descriptor types for object files. */
-
-#define NT_VERSION 1 /* Contains a version string. */
-
-
-/* Dynamic section entry. */
-
-typedef struct
-{
- Elf32_Sword d_tag; /* Dynamic entry type */
- union
- {
- Elf32_Word d_val; /* Integer value */
- Elf32_Addr d_ptr; /* Address value */
- } d_un;
-} Elf32_Dyn;
-
-typedef struct
-{
- Elf64_Sxword d_tag; /* Dynamic entry type */
- union
- {
- Elf64_Xword d_val; /* Integer value */
- Elf64_Addr d_ptr; /* Address value */
- } d_un;
-} Elf64_Dyn;
-
-/* Legal values for d_tag (dynamic entry type). */
-
-#define DT_NULL 0 /* Marks end of dynamic section */
-#define DT_NEEDED 1 /* Name of needed library */
-#define DT_PLTRELSZ 2 /* Size in bytes of PLT relocs */
-#define DT_PLTGOT 3 /* Processor defined value */
-#define DT_HASH 4 /* Address of symbol hash table */
-#define DT_STRTAB 5 /* Address of string table */
-#define DT_SYMTAB 6 /* Address of symbol table */
-#define DT_RELA 7 /* Address of Rela relocs */
-#define DT_RELASZ 8 /* Total size of Rela relocs */
-#define DT_RELAENT 9 /* Size of one Rela reloc */
-#define DT_STRSZ 10 /* Size of string table */
-#define DT_SYMENT 11 /* Size of one symbol table entry */
-#define DT_INIT 12 /* Address of init function */
-#define DT_FINI 13 /* Address of termination function */
-#define DT_SONAME 14 /* Name of shared object */
-#define DT_RPATH 15 /* Library search path (deprecated) */
-#define DT_SYMBOLIC 16 /* Start symbol search here */
-#define DT_REL 17 /* Address of Rel relocs */
-#define DT_RELSZ 18 /* Total size of Rel relocs */
-#define DT_RELENT 19 /* Size of one Rel reloc */
-#define DT_PLTREL 20 /* Type of reloc in PLT */
-#define DT_DEBUG 21 /* For debugging; unspecified */
-#define DT_TEXTREL 22 /* Reloc might modify .text */
-#define DT_JMPREL 23 /* Address of PLT relocs */
-#define DT_BIND_NOW 24 /* Process relocations of object */
-#define DT_INIT_ARRAY 25 /* Array with addresses of init fct */
-#define DT_FINI_ARRAY 26 /* Array with addresses of fini fct */
-#define DT_INIT_ARRAYSZ 27 /* Size in bytes of DT_INIT_ARRAY */
-#define DT_FINI_ARRAYSZ 28 /* Size in bytes of DT_FINI_ARRAY */
-#define DT_RUNPATH 29 /* Library search path */
-#define DT_FLAGS 30 /* Flags for the object being loaded */
-#define DT_ENCODING 32 /* Start of encoded range */
-#define DT_PREINIT_ARRAY 32 /* Array with addresses of preinit fct*/
-#define DT_PREINIT_ARRAYSZ 33 /* size in bytes of DT_PREINIT_ARRAY */
-#define DT_NUM 34 /* Number used */
-#define DT_LOOS 0x6000000d /* Start of OS-specific */
-#define DT_HIOS 0x6ffff000 /* End of OS-specific */
-#define DT_LOPROC 0x70000000 /* Start of processor-specific */
-#define DT_HIPROC 0x7fffffff /* End of processor-specific */
-#define DT_PROCNUM DT_MIPS_NUM /* Most used by any processor */
-
-/* DT_* entries which fall between DT_VALRNGHI & DT_VALRNGLO use the
- Dyn.d_un.d_val field of the Elf*_Dyn structure. This follows Sun's
- approach. */
-#define DT_VALRNGLO 0x6ffffd00
-#define DT_GNU_PRELINKED 0x6ffffdf5 /* Prelinking timestamp */
-#define DT_GNU_CONFLICTSZ 0x6ffffdf6 /* Size of conflict section */
-#define DT_GNU_LIBLISTSZ 0x6ffffdf7 /* Size of library list */
-#define DT_CHECKSUM 0x6ffffdf8
-#define DT_PLTPADSZ 0x6ffffdf9
-#define DT_MOVEENT 0x6ffffdfa
-#define DT_MOVESZ 0x6ffffdfb
-#define DT_FEATURE_1 0x6ffffdfc /* Feature selection (DTF_*). */
-#define DT_POSFLAG_1 0x6ffffdfd /* Flags for DT_* entries, effecting
- the following DT_* entry. */
-#define DT_SYMINSZ 0x6ffffdfe /* Size of syminfo table (in bytes) */
-#define DT_SYMINENT 0x6ffffdff /* Entry size of syminfo */
-#define DT_VALRNGHI 0x6ffffdff
-#define DT_VALTAGIDX(tag) (DT_VALRNGHI - (tag)) /* Reverse order! */
-#define DT_VALNUM 12
-
-/* DT_* entries which fall between DT_ADDRRNGHI & DT_ADDRRNGLO use the
- Dyn.d_un.d_ptr field of the Elf*_Dyn structure.
-
- If any adjustment is made to the ELF object after it has been
- built these entries will need to be adjusted. */
-#define DT_ADDRRNGLO 0x6ffffe00
-#define DT_GNU_HASH 0x6ffffef5 /* GNU-style hash table. */
-#define DT_TLSDESC_PLT 0x6ffffef6
-#define DT_TLSDESC_GOT 0x6ffffef7
-#define DT_GNU_CONFLICT 0x6ffffef8 /* Start of conflict section */
-#define DT_GNU_LIBLIST 0x6ffffef9 /* Library list */
-#define DT_CONFIG 0x6ffffefa /* Configuration information. */
-#define DT_DEPAUDIT 0x6ffffefb /* Dependency auditing. */
-#define DT_AUDIT 0x6ffffefc /* Object auditing. */
-#define DT_PLTPAD 0x6ffffefd /* PLT padding. */
-#define DT_MOVETAB 0x6ffffefe /* Move table. */
-#define DT_SYMINFO 0x6ffffeff /* Syminfo table. */
-#define DT_ADDRRNGHI 0x6ffffeff
-#define DT_ADDRTAGIDX(tag) (DT_ADDRRNGHI - (tag)) /* Reverse order! */
-#define DT_ADDRNUM 11
-
-/* The versioning entry types. The next are defined as part of the
- GNU extension. */
-#define DT_VERSYM 0x6ffffff0
-
-#define DT_RELACOUNT 0x6ffffff9
-#define DT_RELCOUNT 0x6ffffffa
-
-/* These were chosen by Sun. */
-#define DT_FLAGS_1 0x6ffffffb /* State flags, see DF_1_* below. */
-#define DT_VERDEF 0x6ffffffc /* Address of version definition
- table */
-#define DT_VERDEFNUM 0x6ffffffd /* Number of version definitions */
-#define DT_VERNEED 0x6ffffffe /* Address of table with needed
- versions */
-#define DT_VERNEEDNUM 0x6fffffff /* Number of needed versions */
-#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
-#define DT_VERSIONTAGNUM 16
-
-/* Sun added these machine-independent extensions in the "processor-specific"
- range. Be compatible. */
-#define DT_AUXILIARY 0x7ffffffd /* Shared object to load before self */
-#define DT_FILTER 0x7fffffff /* Shared object to get values from */
-#define DT_EXTRATAGIDX(tag) ((Elf32_Word)-((Elf32_Sword) (tag) <<1>>1)-1)
-#define DT_EXTRANUM 3
-
-/* Values of `d_un.d_val' in the DT_FLAGS entry. */
-#define DF_ORIGIN 0x00000001 /* Object may use DF_ORIGIN */
-#define DF_SYMBOLIC 0x00000002 /* Symbol resolutions starts here */
-#define DF_TEXTREL 0x00000004 /* Object contains text relocations */
-#define DF_BIND_NOW 0x00000008 /* No lazy binding for this object */
-#define DF_STATIC_TLS 0x00000010 /* Module uses the static TLS model */
-
-/* State flags selectable in the `d_un.d_val' element of the DT_FLAGS_1
- entry in the dynamic section. */
-#define DF_1_NOW 0x00000001 /* Set RTLD_NOW for this object. */
-#define DF_1_GLOBAL 0x00000002 /* Set RTLD_GLOBAL for this object. */
-#define DF_1_GROUP 0x00000004 /* Set RTLD_GROUP for this object. */
-#define DF_1_NODELETE 0x00000008 /* Set RTLD_NODELETE for this object.*/
-#define DF_1_LOADFLTR 0x00000010 /* Trigger filtee loading at runtime.*/
-#define DF_1_INITFIRST 0x00000020 /* Set RTLD_INITFIRST for this object*/
-#define DF_1_NOOPEN 0x00000040 /* Set RTLD_NOOPEN for this object. */
-#define DF_1_ORIGIN 0x00000080 /* $ORIGIN must be handled. */
-#define DF_1_DIRECT 0x00000100 /* Direct binding enabled. */
-#define DF_1_TRANS 0x00000200
-#define DF_1_INTERPOSE 0x00000400 /* Object is used to interpose. */
-#define DF_1_NODEFLIB 0x00000800 /* Ignore default lib search path. */
-#define DF_1_NODUMP 0x00001000 /* Object can't be dldump'ed. */
-#define DF_1_CONFALT 0x00002000 /* Configuration alternative created.*/
-#define DF_1_ENDFILTEE 0x00004000 /* Filtee terminates filters search. */
-#define DF_1_DISPRELDNE 0x00008000 /* Disp reloc applied at build time. */
-#define DF_1_DISPRELPND 0x00010000 /* Disp reloc applied at run-time. */
-
-/* Flags for the feature selection in DT_FEATURE_1. */
-#define DTF_1_PARINIT 0x00000001
-#define DTF_1_CONFEXP 0x00000002
-
-/* Flags in the DT_POSFLAG_1 entry effecting only the next DT_* entry. */
-#define DF_P1_LAZYLOAD 0x00000001 /* Lazyload following object. */
-#define DF_P1_GROUPPERM 0x00000002 /* Symbols from next object are not
- generally available. */
-
-/* Version definition sections. */
-
-typedef struct
-{
- Elf32_Half vd_version; /* Version revision */
- Elf32_Half vd_flags; /* Version information */
- Elf32_Half vd_ndx; /* Version Index */
- Elf32_Half vd_cnt; /* Number of associated aux entries */
- Elf32_Word vd_hash; /* Version name hash value */
- Elf32_Word vd_aux; /* Offset in bytes to verdaux array */
- Elf32_Word vd_next; /* Offset in bytes to next verdef
- entry */
-} Elf32_Verdef;
-
-typedef struct
-{
- Elf64_Half vd_version; /* Version revision */
- Elf64_Half vd_flags; /* Version information */
- Elf64_Half vd_ndx; /* Version Index */
- Elf64_Half vd_cnt; /* Number of associated aux entries */
- Elf64_Word vd_hash; /* Version name hash value */
- Elf64_Word vd_aux; /* Offset in bytes to verdaux array */
- Elf64_Word vd_next; /* Offset in bytes to next verdef
- entry */
-} Elf64_Verdef;
-
-
-/* Legal values for vd_version (version revision). */
-#define VER_DEF_NONE 0 /* No version */
-#define VER_DEF_CURRENT 1 /* Current version */
-#define VER_DEF_NUM 2 /* Given version number */
-
-/* Legal values for vd_flags (version information flags). */
-#define VER_FLG_BASE 0x1 /* Version definition of file itself */
-#define VER_FLG_WEAK 0x2 /* Weak version identifier */
-
-/* Versym symbol index values. */
-#define VER_NDX_LOCAL 0 /* Symbol is local. */
-#define VER_NDX_GLOBAL 1 /* Symbol is global. */
-#define VER_NDX_LORESERVE 0xff00 /* Beginning of reserved entries. */
-#define VER_NDX_ELIMINATE 0xff01 /* Symbol is to be eliminated. */
-
-/* Auxialiary version information. */
-
-typedef struct
-{
- Elf32_Word vda_name; /* Version or dependency names */
- Elf32_Word vda_next; /* Offset in bytes to next verdaux
- entry */
-} Elf32_Verdaux;
-
-typedef struct
-{
- Elf64_Word vda_name; /* Version or dependency names */
- Elf64_Word vda_next; /* Offset in bytes to next verdaux
- entry */
-} Elf64_Verdaux;
-
-
-/* Version dependency section. */
-
-typedef struct
-{
- Elf32_Half vn_version; /* Version of structure */
- Elf32_Half vn_cnt; /* Number of associated aux entries */
- Elf32_Word vn_file; /* Offset of filename for this
- dependency */
- Elf32_Word vn_aux; /* Offset in bytes to vernaux array */
- Elf32_Word vn_next; /* Offset in bytes to next verneed
- entry */
-} Elf32_Verneed;
-
-typedef struct
-{
- Elf64_Half vn_version; /* Version of structure */
- Elf64_Half vn_cnt; /* Number of associated aux entries */
- Elf64_Word vn_file; /* Offset of filename for this
- dependency */
- Elf64_Word vn_aux; /* Offset in bytes to vernaux array */
- Elf64_Word vn_next; /* Offset in bytes to next verneed
- entry */
-} Elf64_Verneed;
-
-
-/* Legal values for vn_version (version revision). */
-#define VER_NEED_NONE 0 /* No version */
-#define VER_NEED_CURRENT 1 /* Current version */
-#define VER_NEED_NUM 2 /* Given version number */
-
-/* Auxiliary needed version information. */
-
-typedef struct
-{
- Elf32_Word vna_hash; /* Hash value of dependency name */
- Elf32_Half vna_flags; /* Dependency specific information */
- Elf32_Half vna_other; /* Unused */
- Elf32_Word vna_name; /* Dependency name string offset */
- Elf32_Word vna_next; /* Offset in bytes to next vernaux
- entry */
-} Elf32_Vernaux;
-
-typedef struct
-{
- Elf64_Word vna_hash; /* Hash value of dependency name */
- Elf64_Half vna_flags; /* Dependency specific information */
- Elf64_Half vna_other; /* Unused */
- Elf64_Word vna_name; /* Dependency name string offset */
- Elf64_Word vna_next; /* Offset in bytes to next vernaux
- entry */
-} Elf64_Vernaux;
-
-
-/* Legal values for vna_flags. */
-#define VER_FLG_WEAK 0x2 /* Weak version identifier */
-
-
-/* Auxiliary vector. */
-
-/* This vector is normally only used by the program interpreter. The
- usual definition in an ABI supplement uses the name auxv_t. The
- vector is not usually defined in a standard <elf.h> file, but it
- can't hurt. We rename it to avoid conflicts. The sizes of these
- types are an arrangement between the exec server and the program
- interpreter, so we don't fully specify them here. */
-
-typedef struct
-{
- uint32_t a_type; /* Entry type */
- union
- {
- uint32_t a_val; /* Integer value */
- /* We use to have pointer elements added here. We cannot do that,
- though, since it does not work when using 32-bit definitions
- on 64-bit platforms and vice versa. */
- } a_un;
-} Elf32_auxv_t;
-
-typedef struct
-{
- uint64_t a_type; /* Entry type */
- union
- {
- uint64_t a_val; /* Integer value */
- /* We use to have pointer elements added here. We cannot do that,
- though, since it does not work when using 32-bit definitions
- on 64-bit platforms and vice versa. */
- } a_un;
-} Elf64_auxv_t;
-
-/* Legal values for a_type (entry type). */
-
-#define AT_NULL 0 /* End of vector */
-#define AT_IGNORE 1 /* Entry should be ignored */
-#define AT_EXECFD 2 /* File descriptor of program */
-#define AT_PHDR 3 /* Program headers for program */
-#define AT_PHENT 4 /* Size of program header entry */
-#define AT_PHNUM 5 /* Number of program headers */
-#define AT_PAGESZ 6 /* System page size */
-#define AT_BASE 7 /* Base address of interpreter */
-#define AT_FLAGS 8 /* Flags */
-#define AT_ENTRY 9 /* Entry point of program */
-#define AT_NOTELF 10 /* Program is not ELF */
-#define AT_UID 11 /* Real uid */
-#define AT_EUID 12 /* Effective uid */
-#define AT_GID 13 /* Real gid */
-#define AT_EGID 14 /* Effective gid */
-#define AT_CLKTCK 17 /* Frequency of times() */
-
-/* Some more special a_type values describing the hardware. */
-#define AT_PLATFORM 15 /* String identifying platform. */
-#define AT_HWCAP 16 /* Machine dependent hints about
- processor capabilities. */
-
-/* This entry gives some information about the FPU initialization
- performed by the kernel. */
-#define AT_FPUCW 18 /* Used FPU control word. */
-
-/* Cache block sizes. */
-#define AT_DCACHEBSIZE 19 /* Data cache block size. */
-#define AT_ICACHEBSIZE 20 /* Instruction cache block size. */
-#define AT_UCACHEBSIZE 21 /* Unified cache block size. */
-
-/* A special ignored value for PPC, used by the kernel to control the
- interpretation of the AUXV. Must be > 16. */
-#define AT_IGNOREPPC 22 /* Entry should be ignored. */
-
-#define AT_SECURE 23 /* Boolean, was exec setuid-like? */
-
-/* Pointer to the global system page used for system calls and other
- nice things. */
-#define AT_SYSINFO 32
-#define AT_SYSINFO_EHDR 33
-
-/* Shapes of the caches. Bits 0-3 contains associativity; bits 4-7 contains
- log2 of line size; mask those to get cache size. */
-#define AT_L1I_CACHESHAPE 34
-#define AT_L1D_CACHESHAPE 35
-#define AT_L2_CACHESHAPE 36
-#define AT_L3_CACHESHAPE 37
-
-/* Note section contents. Each entry in the note section begins with
- a header of a fixed form. */
-
-typedef struct
-{
- Elf32_Word n_namesz; /* Length of the note's name. */
- Elf32_Word n_descsz; /* Length of the note's descriptor. */
- Elf32_Word n_type; /* Type of the note. */
-} Elf32_Nhdr;
-
-typedef struct
-{
- Elf64_Word n_namesz; /* Length of the note's name. */
- Elf64_Word n_descsz; /* Length of the note's descriptor. */
- Elf64_Word n_type; /* Type of the note. */
-} Elf64_Nhdr;
-
-/* Known names of notes. */
-
-/* Solaris entries in the note section have this name. */
-#define ELF_NOTE_SOLARIS "SUNW Solaris"
-
-/* Note entries for GNU systems have this name. */
-#define ELF_NOTE_GNU "GNU"
-
-
-/* Defined types of notes for Solaris. */
-
-/* Value of descriptor (one word) is desired pagesize for the binary. */
-#define ELF_NOTE_PAGESIZE_HINT 1
-
-
-/* Defined note types for GNU systems. */
-
-/* ABI information. The descriptor consists of words:
- word 0: OS descriptor
- word 1: major version of the ABI
- word 2: minor version of the ABI
- word 3: subminor version of the ABI
-*/
-#define NT_GNU_ABI_TAG 1
-#define ELF_NOTE_ABI NT_GNU_ABI_TAG /* Old name. */
-
-/* Known OSes. These values can appear in word 0 of an
- NT_GNU_ABI_TAG note section entry. */
-#define ELF_NOTE_OS_LINUX 0
-#define ELF_NOTE_OS_GNU 1
-#define ELF_NOTE_OS_SOLARIS2 2
-#define ELF_NOTE_OS_FREEBSD 3
-
-/* Synthetic hwcap information. The descriptor begins with two words:
- word 0: number of entries
- word 1: bitmask of enabled entries
- Then follow variable-length entries, one byte followed by a
- '\0'-terminated hwcap name string. The byte gives the bit
- number to test if enabled, (1U << bit) & bitmask. */
-#define NT_GNU_HWCAP 2
-
-/* Build ID bits as generated by ld --build-id.
- The descriptor consists of any nonzero number of bytes. */
-#define NT_GNU_BUILD_ID 3
-
-
-/* Move records. */
-typedef struct
-{
- Elf32_Xword m_value; /* Symbol value. */
- Elf32_Word m_info; /* Size and index. */
- Elf32_Word m_poffset; /* Symbol offset. */
- Elf32_Half m_repeat; /* Repeat count. */
- Elf32_Half m_stride; /* Stride info. */
-} Elf32_Move;
-
-typedef struct
-{
- Elf64_Xword m_value; /* Symbol value. */
- Elf64_Xword m_info; /* Size and index. */
- Elf64_Xword m_poffset; /* Symbol offset. */
- Elf64_Half m_repeat; /* Repeat count. */
- Elf64_Half m_stride; /* Stride info. */
-} Elf64_Move;
-
-/* Macro to construct move records. */
-#define ELF32_M_SYM(info) ((info) >> 8)
-#define ELF32_M_SIZE(info) ((unsigned char) (info))
-#define ELF32_M_INFO(sym, size) (((sym) << 8) + (unsigned char) (size))
-
-#define ELF64_M_SYM(info) ELF32_M_SYM (info)
-#define ELF64_M_SIZE(info) ELF32_M_SIZE (info)
-#define ELF64_M_INFO(sym, size) ELF32_M_INFO (sym, size)
-
-
-/* Motorola 68k specific definitions. */
-
-/* Values for Elf32_Ehdr.e_flags. */
-#define EF_CPU32 0x00810000
-
-/* m68k relocs. */
-
-#define R_68K_NONE 0 /* No reloc */
-#define R_68K_32 1 /* Direct 32 bit */
-#define R_68K_16 2 /* Direct 16 bit */
-#define R_68K_8 3 /* Direct 8 bit */
-#define R_68K_PC32 4 /* PC relative 32 bit */
-#define R_68K_PC16 5 /* PC relative 16 bit */
-#define R_68K_PC8 6 /* PC relative 8 bit */
-#define R_68K_GOT32 7 /* 32 bit PC relative GOT entry */
-#define R_68K_GOT16 8 /* 16 bit PC relative GOT entry */
-#define R_68K_GOT8 9 /* 8 bit PC relative GOT entry */
-#define R_68K_GOT32O 10 /* 32 bit GOT offset */
-#define R_68K_GOT16O 11 /* 16 bit GOT offset */
-#define R_68K_GOT8O 12 /* 8 bit GOT offset */
-#define R_68K_PLT32 13 /* 32 bit PC relative PLT address */
-#define R_68K_PLT16 14 /* 16 bit PC relative PLT address */
-#define R_68K_PLT8 15 /* 8 bit PC relative PLT address */
-#define R_68K_PLT32O 16 /* 32 bit PLT offset */
-#define R_68K_PLT16O 17 /* 16 bit PLT offset */
-#define R_68K_PLT8O 18 /* 8 bit PLT offset */
-#define R_68K_COPY 19 /* Copy symbol at runtime */
-#define R_68K_GLOB_DAT 20 /* Create GOT entry */
-#define R_68K_JMP_SLOT 21 /* Create PLT entry */
-#define R_68K_RELATIVE 22 /* Adjust by program base */
-/* Keep this the last entry. */
-#define R_68K_NUM 23
-
-/* Intel 80386 specific definitions. */
-
-/* i386 relocs. */
-
-#define R_386_NONE 0 /* No reloc */
-#define R_386_32 1 /* Direct 32 bit */
-#define R_386_PC32 2 /* PC relative 32 bit */
-#define R_386_GOT32 3 /* 32 bit GOT entry */
-#define R_386_PLT32 4 /* 32 bit PLT address */
-#define R_386_COPY 5 /* Copy symbol at runtime */
-#define R_386_GLOB_DAT 6 /* Create GOT entry */
-#define R_386_JMP_SLOT 7 /* Create PLT entry */
-#define R_386_RELATIVE 8 /* Adjust by program base */
-#define R_386_GOTOFF 9 /* 32 bit offset to GOT */
-#define R_386_GOTPC 10 /* 32 bit PC relative offset to GOT */
-#define R_386_32PLT 11
-#define R_386_TLS_TPOFF 14 /* Offset in static TLS block */
-#define R_386_TLS_IE 15 /* Address of GOT entry for static TLS
- block offset */
-#define R_386_TLS_GOTIE 16 /* GOT entry for static TLS block
- offset */
-#define R_386_TLS_LE 17 /* Offset relative to static TLS
- block */
-#define R_386_TLS_GD 18 /* Direct 32 bit for GNU version of
- general dynamic thread local data */
-#define R_386_TLS_LDM 19 /* Direct 32 bit for GNU version of
- local dynamic thread local data
- in LE code */
-#define R_386_16 20
-#define R_386_PC16 21
-#define R_386_8 22
-#define R_386_PC8 23
-#define R_386_TLS_GD_32 24 /* Direct 32 bit for general dynamic
- thread local data */
-#define R_386_TLS_GD_PUSH 25 /* Tag for pushl in GD TLS code */
-#define R_386_TLS_GD_CALL 26 /* Relocation for call to
- __tls_get_addr() */
-#define R_386_TLS_GD_POP 27 /* Tag for popl in GD TLS code */
-#define R_386_TLS_LDM_32 28 /* Direct 32 bit for local dynamic
- thread local data in LE code */
-#define R_386_TLS_LDM_PUSH 29 /* Tag for pushl in LDM TLS code */
-#define R_386_TLS_LDM_CALL 30 /* Relocation for call to
- __tls_get_addr() in LDM code */
-#define R_386_TLS_LDM_POP 31 /* Tag for popl in LDM TLS code */
-#define R_386_TLS_LDO_32 32 /* Offset relative to TLS block */
-#define R_386_TLS_IE_32 33 /* GOT entry for negated static TLS
- block offset */
-#define R_386_TLS_LE_32 34 /* Negated offset relative to static
- TLS block */
-#define R_386_TLS_DTPMOD32 35 /* ID of module containing symbol */
-#define R_386_TLS_DTPOFF32 36 /* Offset in TLS block */
-#define R_386_TLS_TPOFF32 37 /* Negated offset in static TLS block */
-/* Keep this the last entry. */
-#define R_386_NUM 38
-
-/* SUN SPARC specific definitions. */
-
-/* Legal values for ST_TYPE subfield of st_info (symbol type). */
-
-#define STT_SPARC_REGISTER 13 /* Global register reserved to app. */
-
-/* Values for Elf64_Ehdr.e_flags. */
-
-#define EF_SPARCV9_MM 3
-#define EF_SPARCV9_TSO 0
-#define EF_SPARCV9_PSO 1
-#define EF_SPARCV9_RMO 2
-#define EF_SPARC_LEDATA 0x800000 /* little endian data */
-#define EF_SPARC_EXT_MASK 0xFFFF00
-#define EF_SPARC_32PLUS 0x000100 /* generic V8+ features */
-#define EF_SPARC_SUN_US1 0x000200 /* Sun UltraSPARC1 extensions */
-#define EF_SPARC_HAL_R1 0x000400 /* HAL R1 extensions */
-#define EF_SPARC_SUN_US3 0x000800 /* Sun UltraSPARCIII extensions */
-
-/* SPARC relocs. */
-
-#define R_SPARC_NONE 0 /* No reloc */
-#define R_SPARC_8 1 /* Direct 8 bit */
-#define R_SPARC_16 2 /* Direct 16 bit */
-#define R_SPARC_32 3 /* Direct 32 bit */
-#define R_SPARC_DISP8 4 /* PC relative 8 bit */
-#define R_SPARC_DISP16 5 /* PC relative 16 bit */
-#define R_SPARC_DISP32 6 /* PC relative 32 bit */
-#define R_SPARC_WDISP30 7 /* PC relative 30 bit shifted */
-#define R_SPARC_WDISP22 8 /* PC relative 22 bit shifted */
-#define R_SPARC_HI22 9 /* High 22 bit */
-#define R_SPARC_22 10 /* Direct 22 bit */
-#define R_SPARC_13 11 /* Direct 13 bit */
-#define R_SPARC_LO10 12 /* Truncated 10 bit */
-#define R_SPARC_GOT10 13 /* Truncated 10 bit GOT entry */
-#define R_SPARC_GOT13 14 /* 13 bit GOT entry */
-#define R_SPARC_GOT22 15 /* 22 bit GOT entry shifted */
-#define R_SPARC_PC10 16 /* PC relative 10 bit truncated */
-#define R_SPARC_PC22 17 /* PC relative 22 bit shifted */
-#define R_SPARC_WPLT30 18 /* 30 bit PC relative PLT address */
-#define R_SPARC_COPY 19 /* Copy symbol at runtime */
-#define R_SPARC_GLOB_DAT 20 /* Create GOT entry */
-#define R_SPARC_JMP_SLOT 21 /* Create PLT entry */
-#define R_SPARC_RELATIVE 22 /* Adjust by program base */
-#define R_SPARC_UA32 23 /* Direct 32 bit unaligned */
-
-/* Additional Sparc64 relocs. */
-
-#define R_SPARC_PLT32 24 /* Direct 32 bit ref to PLT entry */
-#define R_SPARC_HIPLT22 25 /* High 22 bit PLT entry */
-#define R_SPARC_LOPLT10 26 /* Truncated 10 bit PLT entry */
-#define R_SPARC_PCPLT32 27 /* PC rel 32 bit ref to PLT entry */
-#define R_SPARC_PCPLT22 28 /* PC rel high 22 bit PLT entry */
-#define R_SPARC_PCPLT10 29 /* PC rel trunc 10 bit PLT entry */
-#define R_SPARC_10 30 /* Direct 10 bit */
-#define R_SPARC_11 31 /* Direct 11 bit */
-#define R_SPARC_64 32 /* Direct 64 bit */
-#define R_SPARC_OLO10 33 /* 10bit with secondary 13bit addend */
-#define R_SPARC_HH22 34 /* Top 22 bits of direct 64 bit */
-#define R_SPARC_HM10 35 /* High middle 10 bits of ... */
-#define R_SPARC_LM22 36 /* Low middle 22 bits of ... */
-#define R_SPARC_PC_HH22 37 /* Top 22 bits of pc rel 64 bit */
-#define R_SPARC_PC_HM10 38 /* High middle 10 bit of ... */
-#define R_SPARC_PC_LM22 39 /* Low miggle 22 bits of ... */
-#define R_SPARC_WDISP16 40 /* PC relative 16 bit shifted */
-#define R_SPARC_WDISP19 41 /* PC relative 19 bit shifted */
-#define R_SPARC_7 43 /* Direct 7 bit */
-#define R_SPARC_5 44 /* Direct 5 bit */
-#define R_SPARC_6 45 /* Direct 6 bit */
-#define R_SPARC_DISP64 46 /* PC relative 64 bit */
-#define R_SPARC_PLT64 47 /* Direct 64 bit ref to PLT entry */
-#define R_SPARC_HIX22 48 /* High 22 bit complemented */
-#define R_SPARC_LOX10 49 /* Truncated 11 bit complemented */
-#define R_SPARC_H44 50 /* Direct high 12 of 44 bit */
-#define R_SPARC_M44 51 /* Direct mid 22 of 44 bit */
-#define R_SPARC_L44 52 /* Direct low 10 of 44 bit */
-#define R_SPARC_REGISTER 53 /* Global register usage */
-#define R_SPARC_UA64 54 /* Direct 64 bit unaligned */
-#define R_SPARC_UA16 55 /* Direct 16 bit unaligned */
-#define R_SPARC_TLS_GD_HI22 56
-#define R_SPARC_TLS_GD_LO10 57
-#define R_SPARC_TLS_GD_ADD 58
-#define R_SPARC_TLS_GD_CALL 59
-#define R_SPARC_TLS_LDM_HI22 60
-#define R_SPARC_TLS_LDM_LO10 61
-#define R_SPARC_TLS_LDM_ADD 62
-#define R_SPARC_TLS_LDM_CALL 63
-#define R_SPARC_TLS_LDO_HIX22 64
-#define R_SPARC_TLS_LDO_LOX10 65
-#define R_SPARC_TLS_LDO_ADD 66
-#define R_SPARC_TLS_IE_HI22 67
-#define R_SPARC_TLS_IE_LO10 68
-#define R_SPARC_TLS_IE_LD 69
-#define R_SPARC_TLS_IE_LDX 70
-#define R_SPARC_TLS_IE_ADD 71
-#define R_SPARC_TLS_LE_HIX22 72
-#define R_SPARC_TLS_LE_LOX10 73
-#define R_SPARC_TLS_DTPMOD32 74
-#define R_SPARC_TLS_DTPMOD64 75
-#define R_SPARC_TLS_DTPOFF32 76
-#define R_SPARC_TLS_DTPOFF64 77
-#define R_SPARC_TLS_TPOFF32 78
-#define R_SPARC_TLS_TPOFF64 79
-/* Keep this the last entry. */
-#define R_SPARC_NUM 80
-
-/* For Sparc64, legal values for d_tag of Elf64_Dyn. */
-
-#define DT_SPARC_REGISTER 0x70000001
-#define DT_SPARC_NUM 2
-
-/* Bits present in AT_HWCAP on SPARC. */
-
-#define HWCAP_SPARC_FLUSH 1 /* The CPU supports flush insn. */
-#define HWCAP_SPARC_STBAR 2
-#define HWCAP_SPARC_SWAP 4
-#define HWCAP_SPARC_MULDIV 8
-#define HWCAP_SPARC_V9 16 /* The CPU is v9, so v8plus is ok. */
-#define HWCAP_SPARC_ULTRA3 32
-#define HWCAP_SPARC_BLKINIT 64 /* Sun4v with block-init/load-twin. */
-
-/* MIPS R3000 specific definitions. */
-
-/* Legal values for e_flags field of Elf32_Ehdr. */
-
-#define EF_MIPS_NOREORDER 1 /* A .noreorder directive was used */
-#define EF_MIPS_PIC 2 /* Contains PIC code */
-#define EF_MIPS_CPIC 4 /* Uses PIC calling sequence */
-#define EF_MIPS_XGOT 8
-#define EF_MIPS_64BIT_WHIRL 16
-#define EF_MIPS_ABI2 32
-#define EF_MIPS_ABI_ON32 64
-#define EF_MIPS_ARCH 0xf0000000 /* MIPS architecture level */
-
-/* Legal values for MIPS architecture level. */
-
-#define EF_MIPS_ARCH_1 0x00000000 /* -mips1 code. */
-#define EF_MIPS_ARCH_2 0x10000000 /* -mips2 code. */
-#define EF_MIPS_ARCH_3 0x20000000 /* -mips3 code. */
-#define EF_MIPS_ARCH_4 0x30000000 /* -mips4 code. */
-#define EF_MIPS_ARCH_5 0x40000000 /* -mips5 code. */
-#define EF_MIPS_ARCH_32 0x60000000 /* MIPS32 code. */
-#define EF_MIPS_ARCH_64 0x70000000 /* MIPS64 code. */
-
-/* The following are non-official names and should not be used. */
-
-#define E_MIPS_ARCH_1 0x00000000 /* -mips1 code. */
-#define E_MIPS_ARCH_2 0x10000000 /* -mips2 code. */
-#define E_MIPS_ARCH_3 0x20000000 /* -mips3 code. */
-#define E_MIPS_ARCH_4 0x30000000 /* -mips4 code. */
-#define E_MIPS_ARCH_5 0x40000000 /* -mips5 code. */
-#define E_MIPS_ARCH_32 0x60000000 /* MIPS32 code. */
-#define E_MIPS_ARCH_64 0x70000000 /* MIPS64 code. */
-
-/* Special section indices. */
-
-#define SHN_MIPS_ACOMMON 0xff00 /* Allocated common symbols */
-#define SHN_MIPS_TEXT 0xff01 /* Allocated test symbols. */
-#define SHN_MIPS_DATA 0xff02 /* Allocated data symbols. */
-#define SHN_MIPS_SCOMMON 0xff03 /* Small common symbols */
-#define SHN_MIPS_SUNDEFINED 0xff04 /* Small undefined symbols */
-
-/* Legal values for sh_type field of Elf32_Shdr. */
-
-#define SHT_MIPS_LIBLIST 0x70000000 /* Shared objects used in link */
-#define SHT_MIPS_MSYM 0x70000001
-#define SHT_MIPS_CONFLICT 0x70000002 /* Conflicting symbols */
-#define SHT_MIPS_GPTAB 0x70000003 /* Global data area sizes */
-#define SHT_MIPS_UCODE 0x70000004 /* Reserved for SGI/MIPS compilers */
-#define SHT_MIPS_DEBUG 0x70000005 /* MIPS ECOFF debugging information*/
-#define SHT_MIPS_REGINFO 0x70000006 /* Register usage information */
-#define SHT_MIPS_PACKAGE 0x70000007
-#define SHT_MIPS_PACKSYM 0x70000008
-#define SHT_MIPS_RELD 0x70000009
-#define SHT_MIPS_IFACE 0x7000000b
-#define SHT_MIPS_CONTENT 0x7000000c
-#define SHT_MIPS_OPTIONS 0x7000000d /* Miscellaneous options. */
-#define SHT_MIPS_SHDR 0x70000010
-#define SHT_MIPS_FDESC 0x70000011
-#define SHT_MIPS_EXTSYM 0x70000012
-#define SHT_MIPS_DENSE 0x70000013
-#define SHT_MIPS_PDESC 0x70000014
-#define SHT_MIPS_LOCSYM 0x70000015
-#define SHT_MIPS_AUXSYM 0x70000016
-#define SHT_MIPS_OPTSYM 0x70000017
-#define SHT_MIPS_LOCSTR 0x70000018
-#define SHT_MIPS_LINE 0x70000019
-#define SHT_MIPS_RFDESC 0x7000001a
-#define SHT_MIPS_DELTASYM 0x7000001b
-#define SHT_MIPS_DELTAINST 0x7000001c
-#define SHT_MIPS_DELTACLASS 0x7000001d
-#define SHT_MIPS_DWARF 0x7000001e /* DWARF debugging information. */
-#define SHT_MIPS_DELTADECL 0x7000001f
-#define SHT_MIPS_SYMBOL_LIB 0x70000020
-#define SHT_MIPS_EVENTS 0x70000021 /* Event section. */
-#define SHT_MIPS_TRANSLATE 0x70000022
-#define SHT_MIPS_PIXIE 0x70000023
-#define SHT_MIPS_XLATE 0x70000024
-#define SHT_MIPS_XLATE_DEBUG 0x70000025
-#define SHT_MIPS_WHIRL 0x70000026
-#define SHT_MIPS_EH_REGION 0x70000027
-#define SHT_MIPS_XLATE_OLD 0x70000028
-#define SHT_MIPS_PDR_EXCEPTION 0x70000029
-
-/* Legal values for sh_flags field of Elf32_Shdr. */
-
-#define SHF_MIPS_GPREL 0x10000000 /* Must be part of global data area */
-#define SHF_MIPS_MERGE 0x20000000
-#define SHF_MIPS_ADDR 0x40000000
-#define SHF_MIPS_STRINGS 0x80000000
-#define SHF_MIPS_NOSTRIP 0x08000000
-#define SHF_MIPS_LOCAL 0x04000000
-#define SHF_MIPS_NAMES 0x02000000
-#define SHF_MIPS_NODUPE 0x01000000
-
-
-/* Symbol tables. */
-
-/* MIPS specific values for `st_other'. */
-#define STO_MIPS_DEFAULT 0x0
-#define STO_MIPS_INTERNAL 0x1
-#define STO_MIPS_HIDDEN 0x2
-#define STO_MIPS_PROTECTED 0x3
-#define STO_MIPS_SC_ALIGN_UNUSED 0xff
-
-/* MIPS specific values for `st_info'. */
-#define STB_MIPS_SPLIT_COMMON 13
-
-/* Entries found in sections of type SHT_MIPS_GPTAB. */
-
-typedef union
-{
- struct
- {
- Elf32_Word gt_current_g_value; /* -G value used for compilation */
- Elf32_Word gt_unused; /* Not used */
- } gt_header; /* First entry in section */
- struct
- {
- Elf32_Word gt_g_value; /* If this value were used for -G */
- Elf32_Word gt_bytes; /* This many bytes would be used */
- } gt_entry; /* Subsequent entries in section */
-} Elf32_gptab;
-
-/* Entry found in sections of type SHT_MIPS_REGINFO. */
-
-typedef struct
-{
- Elf32_Word ri_gprmask; /* General registers used */
- Elf32_Word ri_cprmask[4]; /* Coprocessor registers used */
- Elf32_Sword ri_gp_value; /* $gp register value */
-} Elf32_RegInfo;
-
-/* Entries found in sections of type SHT_MIPS_OPTIONS. */
-
-typedef struct
-{
- unsigned char kind; /* Determines interpretation of the
- variable part of descriptor. */
- unsigned char size; /* Size of descriptor, including header. */
- Elf32_Section section; /* Section header index of section affected,
- 0 for global options. */
- Elf32_Word info; /* Kind-specific information. */
-} Elf_Options;
-
-/* Values for `kind' field in Elf_Options. */
-
-#define ODK_NULL 0 /* Undefined. */
-#define ODK_REGINFO 1 /* Register usage information. */
-#define ODK_EXCEPTIONS 2 /* Exception processing options. */
-#define ODK_PAD 3 /* Section padding options. */
-#define ODK_HWPATCH 4 /* Hardware workarounds performed */
-#define ODK_FILL 5 /* record the fill value used by the linker. */
-#define ODK_TAGS 6 /* reserve space for desktop tools to write. */
-#define ODK_HWAND 7 /* HW workarounds. 'AND' bits when merging. */
-#define ODK_HWOR 8 /* HW workarounds. 'OR' bits when merging. */
-
-/* Values for `info' in Elf_Options for ODK_EXCEPTIONS entries. */
-
-#define OEX_FPU_MIN 0x1f /* FPE's which MUST be enabled. */
-#define OEX_FPU_MAX 0x1f00 /* FPE's which MAY be enabled. */
-#define OEX_PAGE0 0x10000 /* page zero must be mapped. */
-#define OEX_SMM 0x20000 /* Force sequential memory mode? */
-#define OEX_FPDBUG 0x40000 /* Force floating point debug mode? */
-#define OEX_PRECISEFP OEX_FPDBUG
-#define OEX_DISMISS 0x80000 /* Dismiss invalid address faults? */
-
-#define OEX_FPU_INVAL 0x10
-#define OEX_FPU_DIV0 0x08
-#define OEX_FPU_OFLO 0x04
-#define OEX_FPU_UFLO 0x02
-#define OEX_FPU_INEX 0x01
-
-/* Masks for `info' in Elf_Options for an ODK_HWPATCH entry. */
-
-#define OHW_R4KEOP 0x1 /* R4000 end-of-page patch. */
-#define OHW_R8KPFETCH 0x2 /* may need R8000 prefetch patch. */
-#define OHW_R5KEOP 0x4 /* R5000 end-of-page patch. */
-#define OHW_R5KCVTL 0x8 /* R5000 cvt.[ds].l bug. clean=1. */
-
-#define OPAD_PREFIX 0x1
-#define OPAD_POSTFIX 0x2
-#define OPAD_SYMBOL 0x4
-
-/* Entry found in `.options' section. */
-
-typedef struct
-{
- Elf32_Word hwp_flags1; /* Extra flags. */
- Elf32_Word hwp_flags2; /* Extra flags. */
-} Elf_Options_Hw;
-
-/* Masks for `info' in ElfOptions for ODK_HWAND and ODK_HWOR entries. */
-
-#define OHWA0_R4KEOP_CHECKED 0x00000001
-#define OHWA1_R4KEOP_CLEAN 0x00000002
-
-/* MIPS relocs. */
-
-#define R_MIPS_NONE 0 /* No reloc */
-#define R_MIPS_16 1 /* Direct 16 bit */
-#define R_MIPS_32 2 /* Direct 32 bit */
-#define R_MIPS_REL32 3 /* PC relative 32 bit */
-#define R_MIPS_26 4 /* Direct 26 bit shifted */
-#define R_MIPS_HI16 5 /* High 16 bit */
-#define R_MIPS_LO16 6 /* Low 16 bit */
-#define R_MIPS_GPREL16 7 /* GP relative 16 bit */
-#define R_MIPS_LITERAL 8 /* 16 bit literal entry */
-#define R_MIPS_GOT16 9 /* 16 bit GOT entry */
-#define R_MIPS_PC16 10 /* PC relative 16 bit */
-#define R_MIPS_CALL16 11 /* 16 bit GOT entry for function */
-#define R_MIPS_GPREL32 12 /* GP relative 32 bit */
-
-#define R_MIPS_SHIFT5 16
-#define R_MIPS_SHIFT6 17
-#define R_MIPS_64 18
-#define R_MIPS_GOT_DISP 19
-#define R_MIPS_GOT_PAGE 20
-#define R_MIPS_GOT_OFST 21
-#define R_MIPS_GOT_HI16 22
-#define R_MIPS_GOT_LO16 23
-#define R_MIPS_SUB 24
-#define R_MIPS_INSERT_A 25
-#define R_MIPS_INSERT_B 26
-#define R_MIPS_DELETE 27
-#define R_MIPS_HIGHER 28
-#define R_MIPS_HIGHEST 29
-#define R_MIPS_CALL_HI16 30
-#define R_MIPS_CALL_LO16 31
-#define R_MIPS_SCN_DISP 32
-#define R_MIPS_REL16 33
-#define R_MIPS_ADD_IMMEDIATE 34
-#define R_MIPS_PJUMP 35
-#define R_MIPS_RELGOT 36
-#define R_MIPS_JALR 37
-#define R_MIPS_TLS_DTPMOD32 38 /* Module number 32 bit */
-#define R_MIPS_TLS_DTPREL32 39 /* Module-relative offset 32 bit */
-#define R_MIPS_TLS_DTPMOD64 40 /* Module number 64 bit */
-#define R_MIPS_TLS_DTPREL64 41 /* Module-relative offset 64 bit */
-#define R_MIPS_TLS_GD 42 /* 16 bit GOT offset for GD */
-#define R_MIPS_TLS_LDM 43 /* 16 bit GOT offset for LDM */
-#define R_MIPS_TLS_DTPREL_HI16 44 /* Module-relative offset, high 16 bits */
-#define R_MIPS_TLS_DTPREL_LO16 45 /* Module-relative offset, low 16 bits */
-#define R_MIPS_TLS_GOTTPREL 46 /* 16 bit GOT offset for IE */
-#define R_MIPS_TLS_TPREL32 47 /* TP-relative offset, 32 bit */
-#define R_MIPS_TLS_TPREL64 48 /* TP-relative offset, 64 bit */
-#define R_MIPS_TLS_TPREL_HI16 49 /* TP-relative offset, high 16 bits */
-#define R_MIPS_TLS_TPREL_LO16 50 /* TP-relative offset, low 16 bits */
-#define R_MIPS_GLOB_DAT 51
-/* Keep this the last entry. */
-#define R_MIPS_NUM 52
-
-/* Legal values for p_type field of Elf32_Phdr. */
-
-#define PT_MIPS_REGINFO 0x70000000 /* Register usage information */
-#define PT_MIPS_RTPROC 0x70000001 /* Runtime procedure table. */
-#define PT_MIPS_OPTIONS 0x70000002
-
-/* Special program header types. */
-
-#define PF_MIPS_LOCAL 0x10000000
-
-/* Legal values for d_tag field of Elf32_Dyn. */
-
-#define DT_MIPS_RLD_VERSION 0x70000001 /* Runtime linker interface version */
-#define DT_MIPS_TIME_STAMP 0x70000002 /* Timestamp */
-#define DT_MIPS_ICHECKSUM 0x70000003 /* Checksum */
-#define DT_MIPS_IVERSION 0x70000004 /* Version string (string tbl index) */
-#define DT_MIPS_FLAGS 0x70000005 /* Flags */
-#define DT_MIPS_BASE_ADDRESS 0x70000006 /* Base address */
-#define DT_MIPS_MSYM 0x70000007
-#define DT_MIPS_CONFLICT 0x70000008 /* Address of CONFLICT section */
-#define DT_MIPS_LIBLIST 0x70000009 /* Address of LIBLIST section */
-#define DT_MIPS_LOCAL_GOTNO 0x7000000a /* Number of local GOT entries */
-#define DT_MIPS_CONFLICTNO 0x7000000b /* Number of CONFLICT entries */
-#define DT_MIPS_LIBLISTNO 0x70000010 /* Number of LIBLIST entries */
-#define DT_MIPS_SYMTABNO 0x70000011 /* Number of DYNSYM entries */
-#define DT_MIPS_UNREFEXTNO 0x70000012 /* First external DYNSYM */
-#define DT_MIPS_GOTSYM 0x70000013 /* First GOT entry in DYNSYM */
-#define DT_MIPS_HIPAGENO 0x70000014 /* Number of GOT page table entries */
-#define DT_MIPS_RLD_MAP 0x70000016 /* Address of run time loader map. */
-#define DT_MIPS_DELTA_CLASS 0x70000017 /* Delta C++ class definition. */
-#define DT_MIPS_DELTA_CLASS_NO 0x70000018 /* Number of entries in
- DT_MIPS_DELTA_CLASS. */
-#define DT_MIPS_DELTA_INSTANCE 0x70000019 /* Delta C++ class instances. */
-#define DT_MIPS_DELTA_INSTANCE_NO 0x7000001a /* Number of entries in
- DT_MIPS_DELTA_INSTANCE. */
-#define DT_MIPS_DELTA_RELOC 0x7000001b /* Delta relocations. */
-#define DT_MIPS_DELTA_RELOC_NO 0x7000001c /* Number of entries in
- DT_MIPS_DELTA_RELOC. */
-#define DT_MIPS_DELTA_SYM 0x7000001d /* Delta symbols that Delta
- relocations refer to. */
-#define DT_MIPS_DELTA_SYM_NO 0x7000001e /* Number of entries in
- DT_MIPS_DELTA_SYM. */
-#define DT_MIPS_DELTA_CLASSSYM 0x70000020 /* Delta symbols that hold the
- class declaration. */
-#define DT_MIPS_DELTA_CLASSSYM_NO 0x70000021 /* Number of entries in
- DT_MIPS_DELTA_CLASSSYM. */
-#define DT_MIPS_CXX_FLAGS 0x70000022 /* Flags indicating for C++ flavor. */
-#define DT_MIPS_PIXIE_INIT 0x70000023
-#define DT_MIPS_SYMBOL_LIB 0x70000024
-#define DT_MIPS_LOCALPAGE_GOTIDX 0x70000025
-#define DT_MIPS_LOCAL_GOTIDX 0x70000026
-#define DT_MIPS_HIDDEN_GOTIDX 0x70000027
-#define DT_MIPS_PROTECTED_GOTIDX 0x70000028
-#define DT_MIPS_OPTIONS 0x70000029 /* Address of .options. */
-#define DT_MIPS_INTERFACE 0x7000002a /* Address of .interface. */
-#define DT_MIPS_DYNSTR_ALIGN 0x7000002b
-#define DT_MIPS_INTERFACE_SIZE 0x7000002c /* Size of the .interface section. */
-#define DT_MIPS_RLD_TEXT_RESOLVE_ADDR 0x7000002d /* Address of rld_text_rsolve
- function stored in GOT. */
-#define DT_MIPS_PERF_SUFFIX 0x7000002e /* Default suffix of dso to be added
- by rld on dlopen() calls. */
-#define DT_MIPS_COMPACT_SIZE 0x7000002f /* (O32)Size of compact rel section. */
-#define DT_MIPS_GP_VALUE 0x70000030 /* GP value for aux GOTs. */
-#define DT_MIPS_AUX_DYNAMIC 0x70000031 /* Address of aux .dynamic. */
-#define DT_MIPS_NUM 0x32
-
-/* Legal values for DT_MIPS_FLAGS Elf32_Dyn entry. */
-
-#define RHF_NONE 0 /* No flags */
-#define RHF_QUICKSTART (1 << 0) /* Use quickstart */
-#define RHF_NOTPOT (1 << 1) /* Hash size not power of 2 */
-#define RHF_NO_LIBRARY_REPLACEMENT (1 << 2) /* Ignore LD_LIBRARY_PATH */
-#define RHF_NO_MOVE (1 << 3)
-#define RHF_SGI_ONLY (1 << 4)
-#define RHF_GUARANTEE_INIT (1 << 5)
-#define RHF_DELTA_C_PLUS_PLUS (1 << 6)
-#define RHF_GUARANTEE_START_INIT (1 << 7)
-#define RHF_PIXIE (1 << 8)
-#define RHF_DEFAULT_DELAY_LOAD (1 << 9)
-#define RHF_REQUICKSTART (1 << 10)
-#define RHF_REQUICKSTARTED (1 << 11)
-#define RHF_CORD (1 << 12)
-#define RHF_NO_UNRES_UNDEF (1 << 13)
-#define RHF_RLD_ORDER_SAFE (1 << 14)
-
-/* Entries found in sections of type SHT_MIPS_LIBLIST. */
-
-typedef struct
-{
- Elf32_Word l_name; /* Name (string table index) */
- Elf32_Word l_time_stamp; /* Timestamp */
- Elf32_Word l_checksum; /* Checksum */
- Elf32_Word l_version; /* Interface version */
- Elf32_Word l_flags; /* Flags */
-} Elf32_Lib;
-
-typedef struct
-{
- Elf64_Word l_name; /* Name (string table index) */
- Elf64_Word l_time_stamp; /* Timestamp */
- Elf64_Word l_checksum; /* Checksum */
- Elf64_Word l_version; /* Interface version */
- Elf64_Word l_flags; /* Flags */
-} Elf64_Lib;
-
-
-/* Legal values for l_flags. */
-
-#define LL_NONE 0
-#define LL_EXACT_MATCH (1 << 0) /* Require exact match */
-#define LL_IGNORE_INT_VER (1 << 1) /* Ignore interface version */
-#define LL_REQUIRE_MINOR (1 << 2)
-#define LL_EXPORTS (1 << 3)
-#define LL_DELAY_LOAD (1 << 4)
-#define LL_DELTA (1 << 5)
-
-/* Entries found in sections of type SHT_MIPS_CONFLICT. */
-
-typedef Elf32_Addr Elf32_Conflict;
-
-
-/* HPPA specific definitions. */
-
-/* Legal values for e_flags field of Elf32_Ehdr. */
-
-#define EF_PARISC_TRAPNIL 0x00010000 /* Trap nil pointer dereference. */
-#define EF_PARISC_EXT 0x00020000 /* Program uses arch. extensions. */
-#define EF_PARISC_LSB 0x00040000 /* Program expects little endian. */
-#define EF_PARISC_WIDE 0x00080000 /* Program expects wide mode. */
-#define EF_PARISC_NO_KABP 0x00100000 /* No kernel assisted branch
- prediction. */
-#define EF_PARISC_LAZYSWAP 0x00400000 /* Allow lazy swapping. */
-#define EF_PARISC_ARCH 0x0000ffff /* Architecture version. */
-
-/* Defined values for `e_flags & EF_PARISC_ARCH' are: */
-
-#define EFA_PARISC_1_0 0x020b /* PA-RISC 1.0 big-endian. */
-#define EFA_PARISC_1_1 0x0210 /* PA-RISC 1.1 big-endian. */
-#define EFA_PARISC_2_0 0x0214 /* PA-RISC 2.0 big-endian. */
-
-/* Additional section indeces. */
-
-#define SHN_PARISC_ANSI_COMMON 0xff00 /* Section for tenatively declared
- symbols in ANSI C. */
-#define SHN_PARISC_HUGE_COMMON 0xff01 /* Common blocks in huge model. */
-
-/* Legal values for sh_type field of Elf32_Shdr. */
-
-#define SHT_PARISC_EXT 0x70000000 /* Contains product specific ext. */
-#define SHT_PARISC_UNWIND 0x70000001 /* Unwind information. */
-#define SHT_PARISC_DOC 0x70000002 /* Debug info for optimized code. */
-
-/* Legal values for sh_flags field of Elf32_Shdr. */
-
-#define SHF_PARISC_SHORT 0x20000000 /* Section with short addressing. */
-#define SHF_PARISC_HUGE 0x40000000 /* Section far from gp. */
-#define SHF_PARISC_SBP 0x80000000 /* Static branch prediction code. */
-
-/* Legal values for ST_TYPE subfield of st_info (symbol type). */
-
-#define STT_PARISC_MILLICODE 13 /* Millicode function entry point. */
-
-#define STT_HP_OPAQUE (STT_LOOS + 0x1)
-#define STT_HP_STUB (STT_LOOS + 0x2)
-
-/* HPPA relocs. */
-
-#define R_PARISC_NONE 0 /* No reloc. */
-#define R_PARISC_DIR32 1 /* Direct 32-bit reference. */
-#define R_PARISC_DIR21L 2 /* Left 21 bits of eff. address. */
-#define R_PARISC_DIR17R 3 /* Right 17 bits of eff. address. */
-#define R_PARISC_DIR17F 4 /* 17 bits of eff. address. */
-#define R_PARISC_DIR14R 6 /* Right 14 bits of eff. address. */
-#define R_PARISC_PCREL32 9 /* 32-bit rel. address. */
-#define R_PARISC_PCREL21L 10 /* Left 21 bits of rel. address. */
-#define R_PARISC_PCREL17R 11 /* Right 17 bits of rel. address. */
-#define R_PARISC_PCREL17F 12 /* 17 bits of rel. address. */
-#define R_PARISC_PCREL14R 14 /* Right 14 bits of rel. address. */
-#define R_PARISC_DPREL21L 18 /* Left 21 bits of rel. address. */
-#define R_PARISC_DPREL14R 22 /* Right 14 bits of rel. address. */
-#define R_PARISC_GPREL21L 26 /* GP-relative, left 21 bits. */
-#define R_PARISC_GPREL14R 30 /* GP-relative, right 14 bits. */
-#define R_PARISC_LTOFF21L 34 /* LT-relative, left 21 bits. */
-#define R_PARISC_LTOFF14R 38 /* LT-relative, right 14 bits. */
-#define R_PARISC_SECREL32 41 /* 32 bits section rel. address. */
-#define R_PARISC_SEGBASE 48 /* No relocation, set segment base. */
-#define R_PARISC_SEGREL32 49 /* 32 bits segment rel. address. */
-#define R_PARISC_PLTOFF21L 50 /* PLT rel. address, left 21 bits. */
-#define R_PARISC_PLTOFF14R 54 /* PLT rel. address, right 14 bits. */
-#define R_PARISC_LTOFF_FPTR32 57 /* 32 bits LT-rel. function pointer. */
-#define R_PARISC_LTOFF_FPTR21L 58 /* LT-rel. fct ptr, left 21 bits. */
-#define R_PARISC_LTOFF_FPTR14R 62 /* LT-rel. fct ptr, right 14 bits. */
-#define R_PARISC_FPTR64 64 /* 64 bits function address. */
-#define R_PARISC_PLABEL32 65 /* 32 bits function address. */
-#define R_PARISC_PLABEL21L 66 /* Left 21 bits of fdesc address. */
-#define R_PARISC_PLABEL14R 70 /* Right 14 bits of fdesc address. */
-#define R_PARISC_PCREL64 72 /* 64 bits PC-rel. address. */
-#define R_PARISC_PCREL22F 74 /* 22 bits PC-rel. address. */
-#define R_PARISC_PCREL14WR 75 /* PC-rel. address, right 14 bits. */
-#define R_PARISC_PCREL14DR 76 /* PC rel. address, right 14 bits. */
-#define R_PARISC_PCREL16F 77 /* 16 bits PC-rel. address. */
-#define R_PARISC_PCREL16WF 78 /* 16 bits PC-rel. address. */
-#define R_PARISC_PCREL16DF 79 /* 16 bits PC-rel. address. */
-#define R_PARISC_DIR64 80 /* 64 bits of eff. address. */
-#define R_PARISC_DIR14WR 83 /* 14 bits of eff. address. */
-#define R_PARISC_DIR14DR 84 /* 14 bits of eff. address. */
-#define R_PARISC_DIR16F 85 /* 16 bits of eff. address. */
-#define R_PARISC_DIR16WF 86 /* 16 bits of eff. address. */
-#define R_PARISC_DIR16DF 87 /* 16 bits of eff. address. */
-#define R_PARISC_GPREL64 88 /* 64 bits of GP-rel. address. */
-#define R_PARISC_GPREL14WR 91 /* GP-rel. address, right 14 bits. */
-#define R_PARISC_GPREL14DR 92 /* GP-rel. address, right 14 bits. */
-#define R_PARISC_GPREL16F 93 /* 16 bits GP-rel. address. */
-#define R_PARISC_GPREL16WF 94 /* 16 bits GP-rel. address. */
-#define R_PARISC_GPREL16DF 95 /* 16 bits GP-rel. address. */
-#define R_PARISC_LTOFF64 96 /* 64 bits LT-rel. address. */
-#define R_PARISC_LTOFF14WR 99 /* LT-rel. address, right 14 bits. */
-#define R_PARISC_LTOFF14DR 100 /* LT-rel. address, right 14 bits. */
-#define R_PARISC_LTOFF16F 101 /* 16 bits LT-rel. address. */
-#define R_PARISC_LTOFF16WF 102 /* 16 bits LT-rel. address. */
-#define R_PARISC_LTOFF16DF 103 /* 16 bits LT-rel. address. */
-#define R_PARISC_SECREL64 104 /* 64 bits section rel. address. */
-#define R_PARISC_SEGREL64 112 /* 64 bits segment rel. address. */
-#define R_PARISC_PLTOFF14WR 115 /* PLT-rel. address, right 14 bits. */
-#define R_PARISC_PLTOFF14DR 116 /* PLT-rel. address, right 14 bits. */
-#define R_PARISC_PLTOFF16F 117 /* 16 bits LT-rel. address. */
-#define R_PARISC_PLTOFF16WF 118 /* 16 bits PLT-rel. address. */
-#define R_PARISC_PLTOFF16DF 119 /* 16 bits PLT-rel. address. */
-#define R_PARISC_LTOFF_FPTR64 120 /* 64 bits LT-rel. function ptr. */
-#define R_PARISC_LTOFF_FPTR14WR 123 /* LT-rel. fct. ptr., right 14 bits. */
-#define R_PARISC_LTOFF_FPTR14DR 124 /* LT-rel. fct. ptr., right 14 bits. */
-#define R_PARISC_LTOFF_FPTR16F 125 /* 16 bits LT-rel. function ptr. */
-#define R_PARISC_LTOFF_FPTR16WF 126 /* 16 bits LT-rel. function ptr. */
-#define R_PARISC_LTOFF_FPTR16DF 127 /* 16 bits LT-rel. function ptr. */
-#define R_PARISC_LORESERVE 128
-#define R_PARISC_COPY 128 /* Copy relocation. */
-#define R_PARISC_IPLT 129 /* Dynamic reloc, imported PLT */
-#define R_PARISC_EPLT 130 /* Dynamic reloc, exported PLT */
-#define R_PARISC_TPREL32 153 /* 32 bits TP-rel. address. */
-#define R_PARISC_TPREL21L 154 /* TP-rel. address, left 21 bits. */
-#define R_PARISC_TPREL14R 158 /* TP-rel. address, right 14 bits. */
-#define R_PARISC_LTOFF_TP21L 162 /* LT-TP-rel. address, left 21 bits. */
-#define R_PARISC_LTOFF_TP14R 166 /* LT-TP-rel. address, right 14 bits.*/
-#define R_PARISC_LTOFF_TP14F 167 /* 14 bits LT-TP-rel. address. */
-#define R_PARISC_TPREL64 216 /* 64 bits TP-rel. address. */
-#define R_PARISC_TPREL14WR 219 /* TP-rel. address, right 14 bits. */
-#define R_PARISC_TPREL14DR 220 /* TP-rel. address, right 14 bits. */
-#define R_PARISC_TPREL16F 221 /* 16 bits TP-rel. address. */
-#define R_PARISC_TPREL16WF 222 /* 16 bits TP-rel. address. */
-#define R_PARISC_TPREL16DF 223 /* 16 bits TP-rel. address. */
-#define R_PARISC_LTOFF_TP64 224 /* 64 bits LT-TP-rel. address. */
-#define R_PARISC_LTOFF_TP14WR 227 /* LT-TP-rel. address, right 14 bits.*/
-#define R_PARISC_LTOFF_TP14DR 228 /* LT-TP-rel. address, right 14 bits.*/
-#define R_PARISC_LTOFF_TP16F 229 /* 16 bits LT-TP-rel. address. */
-#define R_PARISC_LTOFF_TP16WF 230 /* 16 bits LT-TP-rel. address. */
-#define R_PARISC_LTOFF_TP16DF 231 /* 16 bits LT-TP-rel. address. */
-#define R_PARISC_GNU_VTENTRY 232
-#define R_PARISC_GNU_VTINHERIT 233
-#define R_PARISC_TLS_GD21L 234 /* GD 21-bit left. */
-#define R_PARISC_TLS_GD14R 235 /* GD 14-bit right. */
-#define R_PARISC_TLS_GDCALL 236 /* GD call to __t_g_a. */
-#define R_PARISC_TLS_LDM21L 237 /* LD module 21-bit left. */
-#define R_PARISC_TLS_LDM14R 238 /* LD module 14-bit right. */
-#define R_PARISC_TLS_LDMCALL 239 /* LD module call to __t_g_a. */
-#define R_PARISC_TLS_LDO21L 240 /* LD offset 21-bit left. */
-#define R_PARISC_TLS_LDO14R 241 /* LD offset 14-bit right. */
-#define R_PARISC_TLS_DTPMOD32 242 /* DTP module 32-bit. */
-#define R_PARISC_TLS_DTPMOD64 243 /* DTP module 64-bit. */
-#define R_PARISC_TLS_DTPOFF32 244 /* DTP offset 32-bit. */
-#define R_PARISC_TLS_DTPOFF64 245 /* DTP offset 32-bit. */
-#define R_PARISC_TLS_LE21L R_PARISC_TPREL21L
-#define R_PARISC_TLS_LE14R R_PARISC_TPREL14R
-#define R_PARISC_TLS_IE21L R_PARISC_LTOFF_TP21L
-#define R_PARISC_TLS_IE14R R_PARISC_LTOFF_TP14R
-#define R_PARISC_TLS_TPREL32 R_PARISC_TPREL32
-#define R_PARISC_TLS_TPREL64 R_PARISC_TPREL64
-#define R_PARISC_HIRESERVE 255
-
-/* Legal values for p_type field of Elf32_Phdr/Elf64_Phdr. */
-
-#define PT_HP_TLS (PT_LOOS + 0x0)
-#define PT_HP_CORE_NONE (PT_LOOS + 0x1)
-#define PT_HP_CORE_VERSION (PT_LOOS + 0x2)
-#define PT_HP_CORE_KERNEL (PT_LOOS + 0x3)
-#define PT_HP_CORE_COMM (PT_LOOS + 0x4)
-#define PT_HP_CORE_PROC (PT_LOOS + 0x5)
-#define PT_HP_CORE_LOADABLE (PT_LOOS + 0x6)
-#define PT_HP_CORE_STACK (PT_LOOS + 0x7)
-#define PT_HP_CORE_SHM (PT_LOOS + 0x8)
-#define PT_HP_CORE_MMF (PT_LOOS + 0x9)
-#define PT_HP_PARALLEL (PT_LOOS + 0x10)
-#define PT_HP_FASTBIND (PT_LOOS + 0x11)
-#define PT_HP_OPT_ANNOT (PT_LOOS + 0x12)
-#define PT_HP_HSL_ANNOT (PT_LOOS + 0x13)
-#define PT_HP_STACK (PT_LOOS + 0x14)
-
-#define PT_PARISC_ARCHEXT 0x70000000
-#define PT_PARISC_UNWIND 0x70000001
-
-/* Legal values for p_flags field of Elf32_Phdr/Elf64_Phdr. */
-
-#define PF_PARISC_SBP 0x08000000
-
-#define PF_HP_PAGE_SIZE 0x00100000
-#define PF_HP_FAR_SHARED 0x00200000
-#define PF_HP_NEAR_SHARED 0x00400000
-#define PF_HP_CODE 0x01000000
-#define PF_HP_MODIFY 0x02000000
-#define PF_HP_LAZYSWAP 0x04000000
-#define PF_HP_SBP 0x08000000
-
-
-/* Alpha specific definitions. */
-
-/* Legal values for e_flags field of Elf64_Ehdr. */
-
-#define EF_ALPHA_32BIT 1 /* All addresses must be < 2GB. */
-#define EF_ALPHA_CANRELAX 2 /* Relocations for relaxing exist. */
-
-/* Legal values for sh_type field of Elf64_Shdr. */
-
-/* These two are primerily concerned with ECOFF debugging info. */
-#define SHT_ALPHA_DEBUG 0x70000001
-#define SHT_ALPHA_REGINFO 0x70000002
-
-/* Legal values for sh_flags field of Elf64_Shdr. */
-
-#define SHF_ALPHA_GPREL 0x10000000
-
-/* Legal values for st_other field of Elf64_Sym. */
-#define STO_ALPHA_NOPV 0x80 /* No PV required. */
-#define STO_ALPHA_STD_GPLOAD 0x88 /* PV only used for initial ldgp. */
-
-/* Alpha relocs. */
-
-#define R_ALPHA_NONE 0 /* No reloc */
-#define R_ALPHA_REFLONG 1 /* Direct 32 bit */
-#define R_ALPHA_REFQUAD 2 /* Direct 64 bit */
-#define R_ALPHA_GPREL32 3 /* GP relative 32 bit */
-#define R_ALPHA_LITERAL 4 /* GP relative 16 bit w/optimization */
-#define R_ALPHA_LITUSE 5 /* Optimization hint for LITERAL */
-#define R_ALPHA_GPDISP 6 /* Add displacement to GP */
-#define R_ALPHA_BRADDR 7 /* PC+4 relative 23 bit shifted */
-#define R_ALPHA_HINT 8 /* PC+4 relative 16 bit shifted */
-#define R_ALPHA_SREL16 9 /* PC relative 16 bit */
-#define R_ALPHA_SREL32 10 /* PC relative 32 bit */
-#define R_ALPHA_SREL64 11 /* PC relative 64 bit */
-#define R_ALPHA_GPRELHIGH 17 /* GP relative 32 bit, high 16 bits */
-#define R_ALPHA_GPRELLOW 18 /* GP relative 32 bit, low 16 bits */
-#define R_ALPHA_GPREL16 19 /* GP relative 16 bit */
-#define R_ALPHA_COPY 24 /* Copy symbol at runtime */
-#define R_ALPHA_GLOB_DAT 25 /* Create GOT entry */
-#define R_ALPHA_JMP_SLOT 26 /* Create PLT entry */
-#define R_ALPHA_RELATIVE 27 /* Adjust by program base */
-#define R_ALPHA_TLS_GD_HI 28
-#define R_ALPHA_TLSGD 29
-#define R_ALPHA_TLS_LDM 30
-#define R_ALPHA_DTPMOD64 31
-#define R_ALPHA_GOTDTPREL 32
-#define R_ALPHA_DTPREL64 33
-#define R_ALPHA_DTPRELHI 34
-#define R_ALPHA_DTPRELLO 35
-#define R_ALPHA_DTPREL16 36
-#define R_ALPHA_GOTTPREL 37
-#define R_ALPHA_TPREL64 38
-#define R_ALPHA_TPRELHI 39
-#define R_ALPHA_TPRELLO 40
-#define R_ALPHA_TPREL16 41
-/* Keep this the last entry. */
-#define R_ALPHA_NUM 46
-
-/* Magic values of the LITUSE relocation addend. */
-#define LITUSE_ALPHA_ADDR 0
-#define LITUSE_ALPHA_BASE 1
-#define LITUSE_ALPHA_BYTOFF 2
-#define LITUSE_ALPHA_JSR 3
-#define LITUSE_ALPHA_TLS_GD 4
-#define LITUSE_ALPHA_TLS_LDM 5
-
-/* Legal values for d_tag of Elf64_Dyn. */
-#define DT_ALPHA_PLTRO (DT_LOPROC + 0)
-#define DT_ALPHA_NUM 1
-
-/* PowerPC specific declarations */
-
-/* Values for Elf32/64_Ehdr.e_flags. */
-#define EF_PPC_EMB 0x80000000 /* PowerPC embedded flag */
-
-/* Cygnus local bits below */
-#define EF_PPC_RELOCATABLE 0x00010000 /* PowerPC -mrelocatable flag*/
-#define EF_PPC_RELOCATABLE_LIB 0x00008000 /* PowerPC -mrelocatable-lib
- flag */
-
-/* PowerPC relocations defined by the ABIs */
-#define R_PPC_NONE 0
-#define R_PPC_ADDR32 1 /* 32bit absolute address */
-#define R_PPC_ADDR24 2 /* 26bit address, 2 bits ignored. */
-#define R_PPC_ADDR16 3 /* 16bit absolute address */
-#define R_PPC_ADDR16_LO 4 /* lower 16bit of absolute address */
-#define R_PPC_ADDR16_HI 5 /* high 16bit of absolute address */
-#define R_PPC_ADDR16_HA 6 /* adjusted high 16bit */
-#define R_PPC_ADDR14 7 /* 16bit address, 2 bits ignored */
-#define R_PPC_ADDR14_BRTAKEN 8
-#define R_PPC_ADDR14_BRNTAKEN 9
-#define R_PPC_REL24 10 /* PC relative 26 bit */
-#define R_PPC_REL14 11 /* PC relative 16 bit */
-#define R_PPC_REL14_BRTAKEN 12
-#define R_PPC_REL14_BRNTAKEN 13
-#define R_PPC_GOT16 14
-#define R_PPC_GOT16_LO 15
-#define R_PPC_GOT16_HI 16
-#define R_PPC_GOT16_HA 17
-#define R_PPC_PLTREL24 18
-#define R_PPC_COPY 19
-#define R_PPC_GLOB_DAT 20
-#define R_PPC_JMP_SLOT 21
-#define R_PPC_RELATIVE 22
-#define R_PPC_LOCAL24PC 23
-#define R_PPC_UADDR32 24
-#define R_PPC_UADDR16 25
-#define R_PPC_REL32 26
-#define R_PPC_PLT32 27
-#define R_PPC_PLTREL32 28
-#define R_PPC_PLT16_LO 29
-#define R_PPC_PLT16_HI 30
-#define R_PPC_PLT16_HA 31
-#define R_PPC_SDAREL16 32
-#define R_PPC_SECTOFF 33
-#define R_PPC_SECTOFF_LO 34
-#define R_PPC_SECTOFF_HI 35
-#define R_PPC_SECTOFF_HA 36
-
-/* PowerPC relocations defined for the TLS access ABI. */
-#define R_PPC_TLS 67 /* none (sym+add)@tls */
-#define R_PPC_DTPMOD32 68 /* word32 (sym+add)@dtpmod */
-#define R_PPC_TPREL16 69 /* half16* (sym+add)@tprel */
-#define R_PPC_TPREL16_LO 70 /* half16 (sym+add)@tprel@l */
-#define R_PPC_TPREL16_HI 71 /* half16 (sym+add)@tprel@h */
-#define R_PPC_TPREL16_HA 72 /* half16 (sym+add)@tprel@ha */
-#define R_PPC_TPREL32 73 /* word32 (sym+add)@tprel */
-#define R_PPC_DTPREL16 74 /* half16* (sym+add)@dtprel */
-#define R_PPC_DTPREL16_LO 75 /* half16 (sym+add)@dtprel@l */
-#define R_PPC_DTPREL16_HI 76 /* half16 (sym+add)@dtprel@h */
-#define R_PPC_DTPREL16_HA 77 /* half16 (sym+add)@dtprel@ha */
-#define R_PPC_DTPREL32 78 /* word32 (sym+add)@dtprel */
-#define R_PPC_GOT_TLSGD16 79 /* half16* (sym+add)@got@tlsgd */
-#define R_PPC_GOT_TLSGD16_LO 80 /* half16 (sym+add)@got@tlsgd@l */
-#define R_PPC_GOT_TLSGD16_HI 81 /* half16 (sym+add)@got@tlsgd@h */
-#define R_PPC_GOT_TLSGD16_HA 82 /* half16 (sym+add)@got@tlsgd@ha */
-#define R_PPC_GOT_TLSLD16 83 /* half16* (sym+add)@got@tlsld */
-#define R_PPC_GOT_TLSLD16_LO 84 /* half16 (sym+add)@got@tlsld@l */
-#define R_PPC_GOT_TLSLD16_HI 85 /* half16 (sym+add)@got@tlsld@h */
-#define R_PPC_GOT_TLSLD16_HA 86 /* half16 (sym+add)@got@tlsld@ha */
-#define R_PPC_GOT_TPREL16 87 /* half16* (sym+add)@got@tprel */
-#define R_PPC_GOT_TPREL16_LO 88 /* half16 (sym+add)@got@tprel@l */
-#define R_PPC_GOT_TPREL16_HI 89 /* half16 (sym+add)@got@tprel@h */
-#define R_PPC_GOT_TPREL16_HA 90 /* half16 (sym+add)@got@tprel@ha */
-#define R_PPC_GOT_DTPREL16 91 /* half16* (sym+add)@got@dtprel */
-#define R_PPC_GOT_DTPREL16_LO 92 /* half16* (sym+add)@got@dtprel@l */
-#define R_PPC_GOT_DTPREL16_HI 93 /* half16* (sym+add)@got@dtprel@h */
-#define R_PPC_GOT_DTPREL16_HA 94 /* half16* (sym+add)@got@dtprel@ha */
-
-/* Keep this the last entry. */
-#define R_PPC_NUM 95
-
-/* The remaining relocs are from the Embedded ELF ABI, and are not
- in the SVR4 ELF ABI. */
-#define R_PPC_EMB_NADDR32 101
-#define R_PPC_EMB_NADDR16 102
-#define R_PPC_EMB_NADDR16_LO 103
-#define R_PPC_EMB_NADDR16_HI 104
-#define R_PPC_EMB_NADDR16_HA 105
-#define R_PPC_EMB_SDAI16 106
-#define R_PPC_EMB_SDA2I16 107
-#define R_PPC_EMB_SDA2REL 108
-#define R_PPC_EMB_SDA21 109 /* 16 bit offset in SDA */
-#define R_PPC_EMB_MRKREF 110
-#define R_PPC_EMB_RELSEC16 111
-#define R_PPC_EMB_RELST_LO 112
-#define R_PPC_EMB_RELST_HI 113
-#define R_PPC_EMB_RELST_HA 114
-#define R_PPC_EMB_BIT_FLD 115
-#define R_PPC_EMB_RELSDA 116 /* 16 bit relative offset in SDA */
-
-/* Diab tool relocations. */
-#define R_PPC_DIAB_SDA21_LO 180 /* like EMB_SDA21, but lower 16 bit */
-#define R_PPC_DIAB_SDA21_HI 181 /* like EMB_SDA21, but high 16 bit */
-#define R_PPC_DIAB_SDA21_HA 182 /* like EMB_SDA21, adjusted high 16 */
-#define R_PPC_DIAB_RELSDA_LO 183 /* like EMB_RELSDA, but lower 16 bit */
-#define R_PPC_DIAB_RELSDA_HI 184 /* like EMB_RELSDA, but high 16 bit */
-#define R_PPC_DIAB_RELSDA_HA 185 /* like EMB_RELSDA, adjusted high 16 */
-
-/* GNU relocs used in PIC code sequences. */
-#define R_PPC_REL16 249 /* word32 (sym-.) */
-#define R_PPC_REL16_LO 250 /* half16 (sym-.)@l */
-#define R_PPC_REL16_HI 251 /* half16 (sym-.)@h */
-#define R_PPC_REL16_HA 252 /* half16 (sym-.)@ha */
-
-/* This is a phony reloc to handle any old fashioned TOC16 references
- that may still be in object files. */
-#define R_PPC_TOC16 255
-
-/* PowerPC specific values for the Dyn d_tag field. */
-#define DT_PPC_GOT (DT_LOPROC + 0)
-#define DT_PPC_NUM 1
-
-/* PowerPC64 relocations defined by the ABIs */
-#define R_PPC64_NONE R_PPC_NONE
-#define R_PPC64_ADDR32 R_PPC_ADDR32 /* 32bit absolute address */
-#define R_PPC64_ADDR24 R_PPC_ADDR24 /* 26bit address, word aligned */
-#define R_PPC64_ADDR16 R_PPC_ADDR16 /* 16bit absolute address */
-#define R_PPC64_ADDR16_LO R_PPC_ADDR16_LO /* lower 16bits of address */
-#define R_PPC64_ADDR16_HI R_PPC_ADDR16_HI /* high 16bits of address. */
-#define R_PPC64_ADDR16_HA R_PPC_ADDR16_HA /* adjusted high 16bits. */
-#define R_PPC64_ADDR14 R_PPC_ADDR14 /* 16bit address, word aligned */
-#define R_PPC64_ADDR14_BRTAKEN R_PPC_ADDR14_BRTAKEN
-#define R_PPC64_ADDR14_BRNTAKEN R_PPC_ADDR14_BRNTAKEN
-#define R_PPC64_REL24 R_PPC_REL24 /* PC-rel. 26 bit, word aligned */
-#define R_PPC64_REL14 R_PPC_REL14 /* PC relative 16 bit */
-#define R_PPC64_REL14_BRTAKEN R_PPC_REL14_BRTAKEN
-#define R_PPC64_REL14_BRNTAKEN R_PPC_REL14_BRNTAKEN
-#define R_PPC64_GOT16 R_PPC_GOT16
-#define R_PPC64_GOT16_LO R_PPC_GOT16_LO
-#define R_PPC64_GOT16_HI R_PPC_GOT16_HI
-#define R_PPC64_GOT16_HA R_PPC_GOT16_HA
-
-#define R_PPC64_COPY R_PPC_COPY
-#define R_PPC64_GLOB_DAT R_PPC_GLOB_DAT
-#define R_PPC64_JMP_SLOT R_PPC_JMP_SLOT
-#define R_PPC64_RELATIVE R_PPC_RELATIVE
-
-#define R_PPC64_UADDR32 R_PPC_UADDR32
-#define R_PPC64_UADDR16 R_PPC_UADDR16
-#define R_PPC64_REL32 R_PPC_REL32
-#define R_PPC64_PLT32 R_PPC_PLT32
-#define R_PPC64_PLTREL32 R_PPC_PLTREL32
-#define R_PPC64_PLT16_LO R_PPC_PLT16_LO
-#define R_PPC64_PLT16_HI R_PPC_PLT16_HI
-#define R_PPC64_PLT16_HA R_PPC_PLT16_HA
-
-#define R_PPC64_SECTOFF R_PPC_SECTOFF
-#define R_PPC64_SECTOFF_LO R_PPC_SECTOFF_LO
-#define R_PPC64_SECTOFF_HI R_PPC_SECTOFF_HI
-#define R_PPC64_SECTOFF_HA R_PPC_SECTOFF_HA
-#define R_PPC64_ADDR30 37 /* word30 (S + A - P) >> 2 */
-#define R_PPC64_ADDR64 38 /* doubleword64 S + A */
-#define R_PPC64_ADDR16_HIGHER 39 /* half16 #higher(S + A) */
-#define R_PPC64_ADDR16_HIGHERA 40 /* half16 #highera(S + A) */
-#define R_PPC64_ADDR16_HIGHEST 41 /* half16 #highest(S + A) */
-#define R_PPC64_ADDR16_HIGHESTA 42 /* half16 #highesta(S + A) */
-#define R_PPC64_UADDR64 43 /* doubleword64 S + A */
-#define R_PPC64_REL64 44 /* doubleword64 S + A - P */
-#define R_PPC64_PLT64 45 /* doubleword64 L + A */
-#define R_PPC64_PLTREL64 46 /* doubleword64 L + A - P */
-#define R_PPC64_TOC16 47 /* half16* S + A - .TOC */
-#define R_PPC64_TOC16_LO 48 /* half16 #lo(S + A - .TOC.) */
-#define R_PPC64_TOC16_HI 49 /* half16 #hi(S + A - .TOC.) */
-#define R_PPC64_TOC16_HA 50 /* half16 #ha(S + A - .TOC.) */
-#define R_PPC64_TOC 51 /* doubleword64 .TOC */
-#define R_PPC64_PLTGOT16 52 /* half16* M + A */
-#define R_PPC64_PLTGOT16_LO 53 /* half16 #lo(M + A) */
-#define R_PPC64_PLTGOT16_HI 54 /* half16 #hi(M + A) */
-#define R_PPC64_PLTGOT16_HA 55 /* half16 #ha(M + A) */
-
-#define R_PPC64_ADDR16_DS 56 /* half16ds* (S + A) >> 2 */
-#define R_PPC64_ADDR16_LO_DS 57 /* half16ds #lo(S + A) >> 2 */
-#define R_PPC64_GOT16_DS 58 /* half16ds* (G + A) >> 2 */
-#define R_PPC64_GOT16_LO_DS 59 /* half16ds #lo(G + A) >> 2 */
-#define R_PPC64_PLT16_LO_DS 60 /* half16ds #lo(L + A) >> 2 */
-#define R_PPC64_SECTOFF_DS 61 /* half16ds* (R + A) >> 2 */
-#define R_PPC64_SECTOFF_LO_DS 62 /* half16ds #lo(R + A) >> 2 */
-#define R_PPC64_TOC16_DS 63 /* half16ds* (S + A - .TOC.) >> 2 */
-#define R_PPC64_TOC16_LO_DS 64 /* half16ds #lo(S + A - .TOC.) >> 2 */
-#define R_PPC64_PLTGOT16_DS 65 /* half16ds* (M + A) >> 2 */
-#define R_PPC64_PLTGOT16_LO_DS 66 /* half16ds #lo(M + A) >> 2 */
-
-/* PowerPC64 relocations defined for the TLS access ABI. */
-#define R_PPC64_TLS 67 /* none (sym+add)@tls */
-#define R_PPC64_DTPMOD64 68 /* doubleword64 (sym+add)@dtpmod */
-#define R_PPC64_TPREL16 69 /* half16* (sym+add)@tprel */
-#define R_PPC64_TPREL16_LO 70 /* half16 (sym+add)@tprel@l */
-#define R_PPC64_TPREL16_HI 71 /* half16 (sym+add)@tprel@h */
-#define R_PPC64_TPREL16_HA 72 /* half16 (sym+add)@tprel@ha */
-#define R_PPC64_TPREL64 73 /* doubleword64 (sym+add)@tprel */
-#define R_PPC64_DTPREL16 74 /* half16* (sym+add)@dtprel */
-#define R_PPC64_DTPREL16_LO 75 /* half16 (sym+add)@dtprel@l */
-#define R_PPC64_DTPREL16_HI 76 /* half16 (sym+add)@dtprel@h */
-#define R_PPC64_DTPREL16_HA 77 /* half16 (sym+add)@dtprel@ha */
-#define R_PPC64_DTPREL64 78 /* doubleword64 (sym+add)@dtprel */
-#define R_PPC64_GOT_TLSGD16 79 /* half16* (sym+add)@got@tlsgd */
-#define R_PPC64_GOT_TLSGD16_LO 80 /* half16 (sym+add)@got@tlsgd@l */
-#define R_PPC64_GOT_TLSGD16_HI 81 /* half16 (sym+add)@got@tlsgd@h */
-#define R_PPC64_GOT_TLSGD16_HA 82 /* half16 (sym+add)@got@tlsgd@ha */
-#define R_PPC64_GOT_TLSLD16 83 /* half16* (sym+add)@got@tlsld */
-#define R_PPC64_GOT_TLSLD16_LO 84 /* half16 (sym+add)@got@tlsld@l */
-#define R_PPC64_GOT_TLSLD16_HI 85 /* half16 (sym+add)@got@tlsld@h */
-#define R_PPC64_GOT_TLSLD16_HA 86 /* half16 (sym+add)@got@tlsld@ha */
-#define R_PPC64_GOT_TPREL16_DS 87 /* half16ds* (sym+add)@got@tprel */
-#define R_PPC64_GOT_TPREL16_LO_DS 88 /* half16ds (sym+add)@got@tprel@l */
-#define R_PPC64_GOT_TPREL16_HI 89 /* half16 (sym+add)@got@tprel@h */
-#define R_PPC64_GOT_TPREL16_HA 90 /* half16 (sym+add)@got@tprel@ha */
-#define R_PPC64_GOT_DTPREL16_DS 91 /* half16ds* (sym+add)@got@dtprel */
-#define R_PPC64_GOT_DTPREL16_LO_DS 92 /* half16ds (sym+add)@got@dtprel@l */
-#define R_PPC64_GOT_DTPREL16_HI 93 /* half16 (sym+add)@got@dtprel@h */
-#define R_PPC64_GOT_DTPREL16_HA 94 /* half16 (sym+add)@got@dtprel@ha */
-#define R_PPC64_TPREL16_DS 95 /* half16ds* (sym+add)@tprel */
-#define R_PPC64_TPREL16_LO_DS 96 /* half16ds (sym+add)@tprel@l */
-#define R_PPC64_TPREL16_HIGHER 97 /* half16 (sym+add)@tprel@higher */
-#define R_PPC64_TPREL16_HIGHERA 98 /* half16 (sym+add)@tprel@highera */
-#define R_PPC64_TPREL16_HIGHEST 99 /* half16 (sym+add)@tprel@highest */
-#define R_PPC64_TPREL16_HIGHESTA 100 /* half16 (sym+add)@tprel@highesta */
-#define R_PPC64_DTPREL16_DS 101 /* half16ds* (sym+add)@dtprel */
-#define R_PPC64_DTPREL16_LO_DS 102 /* half16ds (sym+add)@dtprel@l */
-#define R_PPC64_DTPREL16_HIGHER 103 /* half16 (sym+add)@dtprel@higher */
-#define R_PPC64_DTPREL16_HIGHERA 104 /* half16 (sym+add)@dtprel@highera */
-#define R_PPC64_DTPREL16_HIGHEST 105 /* half16 (sym+add)@dtprel@highest */
-#define R_PPC64_DTPREL16_HIGHESTA 106 /* half16 (sym+add)@dtprel@highesta */
-
-/* Keep this the last entry. */
-#define R_PPC64_NUM 107
-
-/* PowerPC64 specific values for the Dyn d_tag field. */
-#define DT_PPC64_GLINK (DT_LOPROC + 0)
-#define DT_PPC64_OPD (DT_LOPROC + 1)
-#define DT_PPC64_OPDSZ (DT_LOPROC + 2)
-#define DT_PPC64_NUM 3
-
-
-/* ARM specific declarations */
-
-/* Processor specific flags for the ELF header e_flags field. */
-#define EF_ARM_RELEXEC 0x01
-#define EF_ARM_HASENTRY 0x02
-#define EF_ARM_INTERWORK 0x04
-#define EF_ARM_APCS_26 0x08
-#define EF_ARM_APCS_FLOAT 0x10
-#define EF_ARM_PIC 0x20
-#define EF_ARM_ALIGN8 0x40 /* 8-bit structure alignment is in use */
-#define EF_ARM_NEW_ABI 0x80
-#define EF_ARM_OLD_ABI 0x100
-
-/* Other constants defined in the ARM ELF spec. version B-01. */
-/* NB. These conflict with values defined above. */
-#define EF_ARM_SYMSARESORTED 0x04
-#define EF_ARM_DYNSYMSUSESEGIDX 0x08
-#define EF_ARM_MAPSYMSFIRST 0x10
-#define EF_ARM_EABIMASK 0XFF000000
-
-#define EF_ARM_EABI_VERSION(flags) ((flags) & EF_ARM_EABIMASK)
-#define EF_ARM_EABI_UNKNOWN 0x00000000
-#define EF_ARM_EABI_VER1 0x01000000
-#define EF_ARM_EABI_VER2 0x02000000
-
-/* Additional symbol types for Thumb */
-#define STT_ARM_TFUNC 0xd
-
-/* ARM-specific values for sh_flags */
-#define SHF_ARM_ENTRYSECT 0x10000000 /* Section contains an entry point */
-#define SHF_ARM_COMDEF 0x80000000 /* Section may be multiply defined
- in the input to a link step */
-
-/* ARM-specific program header flags */
-#define PF_ARM_SB 0x10000000 /* Segment contains the location
- addressed by the static base */
-
-/* Processor specific values for the Phdr p_type field. */
-#define PT_ARM_EXIDX 0x70000001 /* .ARM.exidx segment */
-
-/* ARM relocs. */
-
-#define R_ARM_NONE 0 /* No reloc */
-#define R_ARM_PC24 1 /* PC relative 26 bit branch */
-#define R_ARM_ABS32 2 /* Direct 32 bit */
-#define R_ARM_REL32 3 /* PC relative 32 bit */
-#define R_ARM_PC13 4
-#define R_ARM_ABS16 5 /* Direct 16 bit */
-#define R_ARM_ABS12 6 /* Direct 12 bit */
-#define R_ARM_THM_ABS5 7
-#define R_ARM_ABS8 8 /* Direct 8 bit */
-#define R_ARM_SBREL32 9
-#define R_ARM_THM_PC22 10
-#define R_ARM_THM_PC8 11
-#define R_ARM_AMP_VCALL9 12
-#define R_ARM_SWI24 13
-#define R_ARM_THM_SWI8 14
-#define R_ARM_XPC25 15
-#define R_ARM_THM_XPC22 16
-#define R_ARM_TLS_DTPMOD32 17 /* ID of module containing symbol */
-#define R_ARM_TLS_DTPOFF32 18 /* Offset in TLS block */
-#define R_ARM_TLS_TPOFF32 19 /* Offset in static TLS block */
-#define R_ARM_COPY 20 /* Copy symbol at runtime */
-#define R_ARM_GLOB_DAT 21 /* Create GOT entry */
-#define R_ARM_JUMP_SLOT 22 /* Create PLT entry */
-#define R_ARM_RELATIVE 23 /* Adjust by program base */
-#define R_ARM_GOTOFF 24 /* 32 bit offset to GOT */
-#define R_ARM_GOTPC 25 /* 32 bit PC relative offset to GOT */
-#define R_ARM_GOT32 26 /* 32 bit GOT entry */
-#define R_ARM_PLT32 27 /* 32 bit PLT address */
-#define R_ARM_ALU_PCREL_7_0 32
-#define R_ARM_ALU_PCREL_15_8 33
-#define R_ARM_ALU_PCREL_23_15 34
-#define R_ARM_LDR_SBREL_11_0 35
-#define R_ARM_ALU_SBREL_19_12 36
-#define R_ARM_ALU_SBREL_27_20 37
-#define R_ARM_GNU_VTENTRY 100
-#define R_ARM_GNU_VTINHERIT 101
-#define R_ARM_THM_PC11 102 /* thumb unconditional branch */
-#define R_ARM_THM_PC9 103 /* thumb conditional branch */
-#define R_ARM_TLS_GD32 104 /* PC-rel 32 bit for global dynamic
- thread local data */
-#define R_ARM_TLS_LDM32 105 /* PC-rel 32 bit for local dynamic
- thread local data */
-#define R_ARM_TLS_LDO32 106 /* 32 bit offset relative to TLS
- block */
-#define R_ARM_TLS_IE32 107 /* PC-rel 32 bit for GOT entry of
- static TLS block offset */
-#define R_ARM_TLS_LE32 108 /* 32 bit offset relative to static
- TLS block */
-#define R_ARM_RXPC25 249
-#define R_ARM_RSBREL32 250
-#define R_ARM_THM_RPC22 251
-#define R_ARM_RREL32 252
-#define R_ARM_RABS22 253
-#define R_ARM_RPC24 254
-#define R_ARM_RBASE 255
-/* Keep this the last entry. */
-#define R_ARM_NUM 256
-
-/* IA-64 specific declarations. */
-
-/* Processor specific flags for the Ehdr e_flags field. */
-#define EF_IA_64_MASKOS 0x0000000f /* os-specific flags */
-#define EF_IA_64_ABI64 0x00000010 /* 64-bit ABI */
-#define EF_IA_64_ARCH 0xff000000 /* arch. version mask */
-
-/* Processor specific values for the Phdr p_type field. */
-#define PT_IA_64_ARCHEXT (PT_LOPROC + 0) /* arch extension bits */
-#define PT_IA_64_UNWIND (PT_LOPROC + 1) /* ia64 unwind bits */
-#define PT_IA_64_HP_OPT_ANOT (PT_LOOS + 0x12)
-#define PT_IA_64_HP_HSL_ANOT (PT_LOOS + 0x13)
-#define PT_IA_64_HP_STACK (PT_LOOS + 0x14)
-
-/* Processor specific flags for the Phdr p_flags field. */
-#define PF_IA_64_NORECOV 0x80000000 /* spec insns w/o recovery */
-
-/* Processor specific values for the Shdr sh_type field. */
-#define SHT_IA_64_EXT (SHT_LOPROC + 0) /* extension bits */
-#define SHT_IA_64_UNWIND (SHT_LOPROC + 1) /* unwind bits */
-
-/* Processor specific flags for the Shdr sh_flags field. */
-#define SHF_IA_64_SHORT 0x10000000 /* section near gp */
-#define SHF_IA_64_NORECOV 0x20000000 /* spec insns w/o recovery */
-
-/* Processor specific values for the Dyn d_tag field. */
-#define DT_IA_64_PLT_RESERVE (DT_LOPROC + 0)
-#define DT_IA_64_NUM 1
-
-/* IA-64 relocations. */
-#define R_IA64_NONE 0x00 /* none */
-#define R_IA64_IMM14 0x21 /* symbol + addend, add imm14 */
-#define R_IA64_IMM22 0x22 /* symbol + addend, add imm22 */
-#define R_IA64_IMM64 0x23 /* symbol + addend, mov imm64 */
-#define R_IA64_DIR32MSB 0x24 /* symbol + addend, data4 MSB */
-#define R_IA64_DIR32LSB 0x25 /* symbol + addend, data4 LSB */
-#define R_IA64_DIR64MSB 0x26 /* symbol + addend, data8 MSB */
-#define R_IA64_DIR64LSB 0x27 /* symbol + addend, data8 LSB */
-#define R_IA64_GPREL22 0x2a /* @gprel(sym + add), add imm22 */
-#define R_IA64_GPREL64I 0x2b /* @gprel(sym + add), mov imm64 */
-#define R_IA64_GPREL32MSB 0x2c /* @gprel(sym + add), data4 MSB */
-#define R_IA64_GPREL32LSB 0x2d /* @gprel(sym + add), data4 LSB */
-#define R_IA64_GPREL64MSB 0x2e /* @gprel(sym + add), data8 MSB */
-#define R_IA64_GPREL64LSB 0x2f /* @gprel(sym + add), data8 LSB */
-#define R_IA64_LTOFF22 0x32 /* @ltoff(sym + add), add imm22 */
-#define R_IA64_LTOFF64I 0x33 /* @ltoff(sym + add), mov imm64 */
-#define R_IA64_PLTOFF22 0x3a /* @pltoff(sym + add), add imm22 */
-#define R_IA64_PLTOFF64I 0x3b /* @pltoff(sym + add), mov imm64 */
-#define R_IA64_PLTOFF64MSB 0x3e /* @pltoff(sym + add), data8 MSB */
-#define R_IA64_PLTOFF64LSB 0x3f /* @pltoff(sym + add), data8 LSB */
-#define R_IA64_FPTR64I 0x43 /* @fptr(sym + add), mov imm64 */
-#define R_IA64_FPTR32MSB 0x44 /* @fptr(sym + add), data4 MSB */
-#define R_IA64_FPTR32LSB 0x45 /* @fptr(sym + add), data4 LSB */
-#define R_IA64_FPTR64MSB 0x46 /* @fptr(sym + add), data8 MSB */
-#define R_IA64_FPTR64LSB 0x47 /* @fptr(sym + add), data8 LSB */
-#define R_IA64_PCREL60B 0x48 /* @pcrel(sym + add), brl */
-#define R_IA64_PCREL21B 0x49 /* @pcrel(sym + add), ptb, call */
-#define R_IA64_PCREL21M 0x4a /* @pcrel(sym + add), chk.s */
-#define R_IA64_PCREL21F 0x4b /* @pcrel(sym + add), fchkf */
-#define R_IA64_PCREL32MSB 0x4c /* @pcrel(sym + add), data4 MSB */
-#define R_IA64_PCREL32LSB 0x4d /* @pcrel(sym + add), data4 LSB */
-#define R_IA64_PCREL64MSB 0x4e /* @pcrel(sym + add), data8 MSB */
-#define R_IA64_PCREL64LSB 0x4f /* @pcrel(sym + add), data8 LSB */
-#define R_IA64_LTOFF_FPTR22 0x52 /* @ltoff(@fptr(s+a)), imm22 */
-#define R_IA64_LTOFF_FPTR64I 0x53 /* @ltoff(@fptr(s+a)), imm64 */
-#define R_IA64_LTOFF_FPTR32MSB 0x54 /* @ltoff(@fptr(s+a)), data4 MSB */
-#define R_IA64_LTOFF_FPTR32LSB 0x55 /* @ltoff(@fptr(s+a)), data4 LSB */
-#define R_IA64_LTOFF_FPTR64MSB 0x56 /* @ltoff(@fptr(s+a)), data8 MSB */
-#define R_IA64_LTOFF_FPTR64LSB 0x57 /* @ltoff(@fptr(s+a)), data8 LSB */
-#define R_IA64_SEGREL32MSB 0x5c /* @segrel(sym + add), data4 MSB */
-#define R_IA64_SEGREL32LSB 0x5d /* @segrel(sym + add), data4 LSB */
-#define R_IA64_SEGREL64MSB 0x5e /* @segrel(sym + add), data8 MSB */
-#define R_IA64_SEGREL64LSB 0x5f /* @segrel(sym + add), data8 LSB */
-#define R_IA64_SECREL32MSB 0x64 /* @secrel(sym + add), data4 MSB */
-#define R_IA64_SECREL32LSB 0x65 /* @secrel(sym + add), data4 LSB */
-#define R_IA64_SECREL64MSB 0x66 /* @secrel(sym + add), data8 MSB */
-#define R_IA64_SECREL64LSB 0x67 /* @secrel(sym + add), data8 LSB */
-#define R_IA64_REL32MSB 0x6c /* data 4 + REL */
-#define R_IA64_REL32LSB 0x6d /* data 4 + REL */
-#define R_IA64_REL64MSB 0x6e /* data 8 + REL */
-#define R_IA64_REL64LSB 0x6f /* data 8 + REL */
-#define R_IA64_LTV32MSB 0x74 /* symbol + addend, data4 MSB */
-#define R_IA64_LTV32LSB 0x75 /* symbol + addend, data4 LSB */
-#define R_IA64_LTV64MSB 0x76 /* symbol + addend, data8 MSB */
-#define R_IA64_LTV64LSB 0x77 /* symbol + addend, data8 LSB */
-#define R_IA64_PCREL21BI 0x79 /* @pcrel(sym + add), 21bit inst */
-#define R_IA64_PCREL22 0x7a /* @pcrel(sym + add), 22bit inst */
-#define R_IA64_PCREL64I 0x7b /* @pcrel(sym + add), 64bit inst */
-#define R_IA64_IPLTMSB 0x80 /* dynamic reloc, imported PLT, MSB */
-#define R_IA64_IPLTLSB 0x81 /* dynamic reloc, imported PLT, LSB */
-#define R_IA64_COPY 0x84 /* copy relocation */
-#define R_IA64_SUB 0x85 /* Addend and symbol difference */
-#define R_IA64_LTOFF22X 0x86 /* LTOFF22, relaxable. */
-#define R_IA64_LDXMOV 0x87 /* Use of LTOFF22X. */
-#define R_IA64_TPREL14 0x91 /* @tprel(sym + add), imm14 */
-#define R_IA64_TPREL22 0x92 /* @tprel(sym + add), imm22 */
-#define R_IA64_TPREL64I 0x93 /* @tprel(sym + add), imm64 */
-#define R_IA64_TPREL64MSB 0x96 /* @tprel(sym + add), data8 MSB */
-#define R_IA64_TPREL64LSB 0x97 /* @tprel(sym + add), data8 LSB */
-#define R_IA64_LTOFF_TPREL22 0x9a /* @ltoff(@tprel(s+a)), imm2 */
-#define R_IA64_DTPMOD64MSB 0xa6 /* @dtpmod(sym + add), data8 MSB */
-#define R_IA64_DTPMOD64LSB 0xa7 /* @dtpmod(sym + add), data8 LSB */
-#define R_IA64_LTOFF_DTPMOD22 0xaa /* @ltoff(@dtpmod(sym + add)), imm22 */
-#define R_IA64_DTPREL14 0xb1 /* @dtprel(sym + add), imm14 */
-#define R_IA64_DTPREL22 0xb2 /* @dtprel(sym + add), imm22 */
-#define R_IA64_DTPREL64I 0xb3 /* @dtprel(sym + add), imm64 */
-#define R_IA64_DTPREL32MSB 0xb4 /* @dtprel(sym + add), data4 MSB */
-#define R_IA64_DTPREL32LSB 0xb5 /* @dtprel(sym + add), data4 LSB */
-#define R_IA64_DTPREL64MSB 0xb6 /* @dtprel(sym + add), data8 MSB */
-#define R_IA64_DTPREL64LSB 0xb7 /* @dtprel(sym + add), data8 LSB */
-#define R_IA64_LTOFF_DTPREL22 0xba /* @ltoff(@dtprel(s+a)), imm22 */
-
-/* SH specific declarations */
-
-/* SH relocs. */
-#define R_SH_NONE 0
-#define R_SH_DIR32 1
-#define R_SH_REL32 2
-#define R_SH_DIR8WPN 3
-#define R_SH_IND12W 4
-#define R_SH_DIR8WPL 5
-#define R_SH_DIR8WPZ 6
-#define R_SH_DIR8BP 7
-#define R_SH_DIR8W 8
-#define R_SH_DIR8L 9
-#define R_SH_SWITCH16 25
-#define R_SH_SWITCH32 26
-#define R_SH_USES 27
-#define R_SH_COUNT 28
-#define R_SH_ALIGN 29
-#define R_SH_CODE 30
-#define R_SH_DATA 31
-#define R_SH_LABEL 32
-#define R_SH_SWITCH8 33
-#define R_SH_GNU_VTINHERIT 34
-#define R_SH_GNU_VTENTRY 35
-#define R_SH_TLS_GD_32 144
-#define R_SH_TLS_LD_32 145
-#define R_SH_TLS_LDO_32 146
-#define R_SH_TLS_IE_32 147
-#define R_SH_TLS_LE_32 148
-#define R_SH_TLS_DTPMOD32 149
-#define R_SH_TLS_DTPOFF32 150
-#define R_SH_TLS_TPOFF32 151
-#define R_SH_GOT32 160
-#define R_SH_PLT32 161
-#define R_SH_COPY 162
-#define R_SH_GLOB_DAT 163
-#define R_SH_JMP_SLOT 164
-#define R_SH_RELATIVE 165
-#define R_SH_GOTOFF 166
-#define R_SH_GOTPC 167
-/* Keep this the last entry. */
-#define R_SH_NUM 256
-
-/* Additional s390 relocs */
-
-#define R_390_NONE 0 /* No reloc. */
-#define R_390_8 1 /* Direct 8 bit. */
-#define R_390_12 2 /* Direct 12 bit. */
-#define R_390_16 3 /* Direct 16 bit. */
-#define R_390_32 4 /* Direct 32 bit. */
-#define R_390_PC32 5 /* PC relative 32 bit. */
-#define R_390_GOT12 6 /* 12 bit GOT offset. */
-#define R_390_GOT32 7 /* 32 bit GOT offset. */
-#define R_390_PLT32 8 /* 32 bit PC relative PLT address. */
-#define R_390_COPY 9 /* Copy symbol at runtime. */
-#define R_390_GLOB_DAT 10 /* Create GOT entry. */
-#define R_390_JMP_SLOT 11 /* Create PLT entry. */
-#define R_390_RELATIVE 12 /* Adjust by program base. */
-#define R_390_GOTOFF32 13 /* 32 bit offset to GOT. */
-#define R_390_GOTPC 14 /* 32 bit PC relative offset to GOT. */
-#define R_390_GOT16 15 /* 16 bit GOT offset. */
-#define R_390_PC16 16 /* PC relative 16 bit. */
-#define R_390_PC16DBL 17 /* PC relative 16 bit shifted by 1. */
-#define R_390_PLT16DBL 18 /* 16 bit PC rel. PLT shifted by 1. */
-#define R_390_PC32DBL 19 /* PC relative 32 bit shifted by 1. */
-#define R_390_PLT32DBL 20 /* 32 bit PC rel. PLT shifted by 1. */
-#define R_390_GOTPCDBL 21 /* 32 bit PC rel. GOT shifted by 1. */
-#define R_390_64 22 /* Direct 64 bit. */
-#define R_390_PC64 23 /* PC relative 64 bit. */
-#define R_390_GOT64 24 /* 64 bit GOT offset. */
-#define R_390_PLT64 25 /* 64 bit PC relative PLT address. */
-#define R_390_GOTENT 26 /* 32 bit PC rel. to GOT entry >> 1. */
-#define R_390_GOTOFF16 27 /* 16 bit offset to GOT. */
-#define R_390_GOTOFF64 28 /* 64 bit offset to GOT. */
-#define R_390_GOTPLT12 29 /* 12 bit offset to jump slot. */
-#define R_390_GOTPLT16 30 /* 16 bit offset to jump slot. */
-#define R_390_GOTPLT32 31 /* 32 bit offset to jump slot. */
-#define R_390_GOTPLT64 32 /* 64 bit offset to jump slot. */
-#define R_390_GOTPLTENT 33 /* 32 bit rel. offset to jump slot. */
-#define R_390_PLTOFF16 34 /* 16 bit offset from GOT to PLT. */
-#define R_390_PLTOFF32 35 /* 32 bit offset from GOT to PLT. */
-#define R_390_PLTOFF64 36 /* 16 bit offset from GOT to PLT. */
-#define R_390_TLS_LOAD 37 /* Tag for load insn in TLS code. */
-#define R_390_TLS_GDCALL 38 /* Tag for function call in general
- dynamic TLS code. */
-#define R_390_TLS_LDCALL 39 /* Tag for function call in local
- dynamic TLS code. */
-#define R_390_TLS_GD32 40 /* Direct 32 bit for general dynamic
- thread local data. */
-#define R_390_TLS_GD64 41 /* Direct 64 bit for general dynamic
- thread local data. */
-#define R_390_TLS_GOTIE12 42 /* 12 bit GOT offset for static TLS
- block offset. */
-#define R_390_TLS_GOTIE32 43 /* 32 bit GOT offset for static TLS
- block offset. */
-#define R_390_TLS_GOTIE64 44 /* 64 bit GOT offset for static TLS
- block offset. */
-#define R_390_TLS_LDM32 45 /* Direct 32 bit for local dynamic
- thread local data in LE code. */
-#define R_390_TLS_LDM64 46 /* Direct 64 bit for local dynamic
- thread local data in LE code. */
-#define R_390_TLS_IE32 47 /* 32 bit address of GOT entry for
- negated static TLS block offset. */
-#define R_390_TLS_IE64 48 /* 64 bit address of GOT entry for
- negated static TLS block offset. */
-#define R_390_TLS_IEENT 49 /* 32 bit rel. offset to GOT entry for
- negated static TLS block offset. */
-#define R_390_TLS_LE32 50 /* 32 bit negated offset relative to
- static TLS block. */
-#define R_390_TLS_LE64 51 /* 64 bit negated offset relative to
- static TLS block. */
-#define R_390_TLS_LDO32 52 /* 32 bit offset relative to TLS
- block. */
-#define R_390_TLS_LDO64 53 /* 64 bit offset relative to TLS
- block. */
-#define R_390_TLS_DTPMOD 54 /* ID of module containing symbol. */
-#define R_390_TLS_DTPOFF 55 /* Offset in TLS block. */
-#define R_390_TLS_TPOFF 56 /* Negated offset in static TLS
- block. */
-#define R_390_20 57 /* Direct 20 bit. */
-#define R_390_GOT20 58 /* 20 bit GOT offset. */
-#define R_390_GOTPLT20 59 /* 20 bit offset to jump slot. */
-#define R_390_TLS_GOTIE20 60 /* 20 bit GOT offset for static TLS
- block offset. */
-/* Keep this the last entry. */
-#define R_390_NUM 61
-
-
-/* CRIS relocations. */
-#define R_CRIS_NONE 0
-#define R_CRIS_8 1
-#define R_CRIS_16 2
-#define R_CRIS_32 3
-#define R_CRIS_8_PCREL 4
-#define R_CRIS_16_PCREL 5
-#define R_CRIS_32_PCREL 6
-#define R_CRIS_GNU_VTINHERIT 7
-#define R_CRIS_GNU_VTENTRY 8
-#define R_CRIS_COPY 9
-#define R_CRIS_GLOB_DAT 10
-#define R_CRIS_JUMP_SLOT 11
-#define R_CRIS_RELATIVE 12
-#define R_CRIS_16_GOT 13
-#define R_CRIS_32_GOT 14
-#define R_CRIS_16_GOTPLT 15
-#define R_CRIS_32_GOTPLT 16
-#define R_CRIS_32_GOTREL 17
-#define R_CRIS_32_PLT_GOTREL 18
-#define R_CRIS_32_PLT_PCREL 19
-
-#define R_CRIS_NUM 20
-
-
-/* AMD x86-64 relocations. */
-#define R_X86_64_NONE 0 /* No reloc */
-#define R_X86_64_64 1 /* Direct 64 bit */
-#define R_X86_64_PC32 2 /* PC relative 32 bit signed */
-#define R_X86_64_GOT32 3 /* 32 bit GOT entry */
-#define R_X86_64_PLT32 4 /* 32 bit PLT address */
-#define R_X86_64_COPY 5 /* Copy symbol at runtime */
-#define R_X86_64_GLOB_DAT 6 /* Create GOT entry */
-#define R_X86_64_JUMP_SLOT 7 /* Create PLT entry */
-#define R_X86_64_RELATIVE 8 /* Adjust by program base */
-#define R_X86_64_GOTPCREL 9 /* 32 bit signed PC relative
- offset to GOT */
-#define R_X86_64_32 10 /* Direct 32 bit zero extended */
-#define R_X86_64_32S 11 /* Direct 32 bit sign extended */
-#define R_X86_64_16 12 /* Direct 16 bit zero extended */
-#define R_X86_64_PC16 13 /* 16 bit sign extended pc relative */
-#define R_X86_64_8 14 /* Direct 8 bit sign extended */
-#define R_X86_64_PC8 15 /* 8 bit sign extended pc relative */
-#define R_X86_64_DTPMOD64 16 /* ID of module containing symbol */
-#define R_X86_64_DTPOFF64 17 /* Offset in module's TLS block */
-#define R_X86_64_TPOFF64 18 /* Offset in initial TLS block */
-#define R_X86_64_TLSGD 19 /* 32 bit signed PC relative offset
- to two GOT entries for GD symbol */
-#define R_X86_64_TLSLD 20 /* 32 bit signed PC relative offset
- to two GOT entries for LD symbol */
-#define R_X86_64_DTPOFF32 21 /* Offset in TLS block */
-#define R_X86_64_GOTTPOFF 22 /* 32 bit signed PC relative offset
- to GOT entry for IE symbol */
-#define R_X86_64_TPOFF32 23 /* Offset in initial TLS block */
-
-#define R_X86_64_NUM 24
-
-
-/* AM33 relocations. */
-#define R_MN10300_NONE 0 /* No reloc. */
-#define R_MN10300_32 1 /* Direct 32 bit. */
-#define R_MN10300_16 2 /* Direct 16 bit. */
-#define R_MN10300_8 3 /* Direct 8 bit. */
-#define R_MN10300_PCREL32 4 /* PC-relative 32-bit. */
-#define R_MN10300_PCREL16 5 /* PC-relative 16-bit signed. */
-#define R_MN10300_PCREL8 6 /* PC-relative 8-bit signed. */
-#define R_MN10300_GNU_VTINHERIT 7 /* Ancient C++ vtable garbage... */
-#define R_MN10300_GNU_VTENTRY 8 /* ... collection annotation. */
-#define R_MN10300_24 9 /* Direct 24 bit. */
-#define R_MN10300_GOTPC32 10 /* 32-bit PCrel offset to GOT. */
-#define R_MN10300_GOTPC16 11 /* 16-bit PCrel offset to GOT. */
-#define R_MN10300_GOTOFF32 12 /* 32-bit offset from GOT. */
-#define R_MN10300_GOTOFF24 13 /* 24-bit offset from GOT. */
-#define R_MN10300_GOTOFF16 14 /* 16-bit offset from GOT. */
-#define R_MN10300_PLT32 15 /* 32-bit PCrel to PLT entry. */
-#define R_MN10300_PLT16 16 /* 16-bit PCrel to PLT entry. */
-#define R_MN10300_GOT32 17 /* 32-bit offset to GOT entry. */
-#define R_MN10300_GOT24 18 /* 24-bit offset to GOT entry. */
-#define R_MN10300_GOT16 19 /* 16-bit offset to GOT entry. */
-#define R_MN10300_COPY 20 /* Copy symbol at runtime. */
-#define R_MN10300_GLOB_DAT 21 /* Create GOT entry. */
-#define R_MN10300_JMP_SLOT 22 /* Create PLT entry. */
-#define R_MN10300_RELATIVE 23 /* Adjust by program base. */
-
-#define R_MN10300_NUM 24
-
-
-/* M32R relocs. */
-#define R_M32R_NONE 0 /* No reloc. */
-#define R_M32R_16 1 /* Direct 16 bit. */
-#define R_M32R_32 2 /* Direct 32 bit. */
-#define R_M32R_24 3 /* Direct 24 bit. */
-#define R_M32R_10_PCREL 4 /* PC relative 10 bit shifted. */
-#define R_M32R_18_PCREL 5 /* PC relative 18 bit shifted. */
-#define R_M32R_26_PCREL 6 /* PC relative 26 bit shifted. */
-#define R_M32R_HI16_ULO 7 /* High 16 bit with unsigned low. */
-#define R_M32R_HI16_SLO 8 /* High 16 bit with signed low. */
-#define R_M32R_LO16 9 /* Low 16 bit. */
-#define R_M32R_SDA16 10 /* 16 bit offset in SDA. */
-#define R_M32R_GNU_VTINHERIT 11
-#define R_M32R_GNU_VTENTRY 12
-/* M32R relocs use SHT_RELA. */
-#define R_M32R_16_RELA 33 /* Direct 16 bit. */
-#define R_M32R_32_RELA 34 /* Direct 32 bit. */
-#define R_M32R_24_RELA 35 /* Direct 24 bit. */
-#define R_M32R_10_PCREL_RELA 36 /* PC relative 10 bit shifted. */
-#define R_M32R_18_PCREL_RELA 37 /* PC relative 18 bit shifted. */
-#define R_M32R_26_PCREL_RELA 38 /* PC relative 26 bit shifted. */
-#define R_M32R_HI16_ULO_RELA 39 /* High 16 bit with unsigned low */
-#define R_M32R_HI16_SLO_RELA 40 /* High 16 bit with signed low */
-#define R_M32R_LO16_RELA 41 /* Low 16 bit */
-#define R_M32R_SDA16_RELA 42 /* 16 bit offset in SDA */
-#define R_M32R_RELA_GNU_VTINHERIT 43
-#define R_M32R_RELA_GNU_VTENTRY 44
-#define R_M32R_REL32 45 /* PC relative 32 bit. */
-
-#define R_M32R_GOT24 48 /* 24 bit GOT entry */
-#define R_M32R_26_PLTREL 49 /* 26 bit PC relative to PLT shifted */
-#define R_M32R_COPY 50 /* Copy symbol at runtime */
-#define R_M32R_GLOB_DAT 51 /* Create GOT entry */
-#define R_M32R_JMP_SLOT 52 /* Create PLT entry */
-#define R_M32R_RELATIVE 53 /* Adjust by program base */
-#define R_M32R_GOTOFF 54 /* 24 bit offset to GOT */
-#define R_M32R_GOTPC24 55 /* 24 bit PC relative offset to GOT */
-#define R_M32R_GOT16_HI_ULO 56 /* High 16 bit GOT entry with unsigned
- low */
-#define R_M32R_GOT16_HI_SLO 57 /* High 16 bit GOT entry with signed
- low */
-#define R_M32R_GOT16_LO 58 /* Low 16 bit GOT entry */
-#define R_M32R_GOTPC_HI_ULO 59 /* High 16 bit PC relative offset to
- GOT with unsigned low */
-#define R_M32R_GOTPC_HI_SLO 60 /* High 16 bit PC relative offset to
- GOT with signed low */
-#define R_M32R_GOTPC_LO 61 /* Low 16 bit PC relative offset to
- GOT */
-#define R_M32R_GOTOFF_HI_ULO 62 /* High 16 bit offset to GOT
- with unsigned low */
-#define R_M32R_GOTOFF_HI_SLO 63 /* High 16 bit offset to GOT
- with signed low */
-#define R_M32R_GOTOFF_LO 64 /* Low 16 bit offset to GOT */
-#define R_M32R_NUM 256 /* Keep this the last entry. */
-
-
-#endif /* elf.h */
+++ /dev/null
-// InBuffer.h\r
-\r
-#ifndef __INBUFFER_H\r
-#define __INBUFFER_H\r
-\r
-#include "../IStream.h"\r
-#include "../../Common/MyCom.h"\r
-\r
-#ifndef _NO_EXCEPTIONS\r
-class CInBufferException\r
-{\r
-public:\r
- HRESULT ErrorCode;\r
- CInBufferException(HRESULT errorCode): ErrorCode(errorCode) {}\r
-};\r
-#endif\r
-\r
-class CInBuffer\r
-{\r
- Byte *_buffer;\r
- Byte *_bufferLimit;\r
- Byte *_bufferBase;\r
- CMyComPtr<ISequentialInStream> _stream;\r
- UInt64 _processedSize;\r
- UInt32 _bufferSize;\r
- bool _wasFinished;\r
-\r
- bool ReadBlock();\r
- Byte ReadBlock2();\r
-\r
-public:\r
- #ifdef _NO_EXCEPTIONS\r
- HRESULT ErrorCode;\r
- #endif\r
-\r
- CInBuffer();\r
- ~CInBuffer() { Free(); }\r
-\r
- bool Create(UInt32 bufferSize);\r
- void Free();\r
- \r
- void SetStream(ISequentialInStream *stream);\r
- void Init();\r
- void ReleaseStream() { _stream.Release(); }\r
-\r
- bool ReadByte(Byte &b)\r
- {\r
- if(_buffer >= _bufferLimit)\r
- if(!ReadBlock())\r
- return false;\r
- b = *_buffer++;\r
- return true;\r
- }\r
- Byte ReadByte()\r
- {\r
- if(_buffer >= _bufferLimit)\r
- return ReadBlock2();\r
- return *_buffer++;\r
- }\r
- void ReadBytes(void *data, UInt32 size, UInt32 &processedSize)\r
- {\r
- for(processedSize = 0; processedSize < size; processedSize++)\r
- if (!ReadByte(((Byte *)data)[processedSize]))\r
- return;\r
- }\r
- bool ReadBytes(void *data, UInt32 size)\r
- {\r
- UInt32 processedSize;\r
- ReadBytes(data, size, processedSize);\r
- return (processedSize == size);\r
- }\r
- UInt64 GetProcessedSize() const { return _processedSize + (_buffer - _bufferBase); }\r
- bool WasFinished() const { return _wasFinished; }\r
-};\r
-\r
-#endif\r
+++ /dev/null
-// OutByte.cpp\r
-\r
-#include "StdAfx.h"\r
-\r
-#include "OutBuffer.h"\r
-\r
-#include "../../Common/Alloc.h"\r
-\r
-bool COutBuffer::Create(UInt32 bufferSize)\r
-{\r
- const UInt32 kMinBlockSize = 1;\r
- if (bufferSize < kMinBlockSize)\r
- bufferSize = kMinBlockSize;\r
- if (_buffer != 0 && _bufferSize == bufferSize)\r
- return true;\r
- Free();\r
- _bufferSize = bufferSize;\r
- _buffer = (Byte *)::MidAlloc(bufferSize);\r
- return (_buffer != 0);\r
-}\r
-\r
-void COutBuffer::Free()\r
-{\r
- ::MidFree(_buffer);\r
- _buffer = 0;\r
-}\r
-\r
-void COutBuffer::SetStream(ISequentialOutStream *stream)\r
-{\r
- _stream = stream;\r
-}\r
-\r
-void COutBuffer::Init()\r
-{\r
- _streamPos = 0;\r
- _limitPos = _bufferSize;\r
- _pos = 0;\r
- _processedSize = 0;\r
- _overDict = false;\r
- #ifdef _NO_EXCEPTIONS\r
- ErrorCode = S_OK;\r
- #endif\r
-}\r
-\r
-UInt64 COutBuffer::GetProcessedSize() const\r
-{ \r
- UInt64 res = _processedSize + _pos - _streamPos;\r
- if (_streamPos > _pos) \r
- res += _bufferSize;\r
- return res;\r
-}\r
-\r
-\r
-HRESULT COutBuffer::FlushPart()\r
-{\r
- // _streamPos < _bufferSize\r
- UInt32 size = (_streamPos >= _pos) ? (_bufferSize - _streamPos) : (_pos - _streamPos);\r
- HRESULT result = S_OK;\r
- #ifdef _NO_EXCEPTIONS\r
- result = ErrorCode;\r
- #endif\r
- if (_buffer2 != 0)\r
- {\r
- memmove(_buffer2, _buffer + _streamPos, size);\r
- _buffer2 += size;\r
- }\r
-\r
- if (_stream != 0\r
- #ifdef _NO_EXCEPTIONS\r
- && (ErrorCode == S_OK)\r
- #endif\r
- )\r
- {\r
- UInt32 processedSize = 0;\r
- result = _stream->Write(_buffer + _streamPos, size, &processedSize);\r
- size = processedSize;\r
- }\r
- _streamPos += size;\r
- if (_streamPos == _bufferSize)\r
- _streamPos = 0;\r
- if (_pos == _bufferSize)\r
- {\r
- _overDict = true;\r
- _pos = 0;\r
- }\r
- _limitPos = (_streamPos > _pos) ? _streamPos : _bufferSize;\r
- _processedSize += size;\r
- return result;\r
-}\r
-\r
-HRESULT COutBuffer::Flush()\r
-{\r
- #ifdef _NO_EXCEPTIONS\r
- if (ErrorCode != S_OK)\r
- return ErrorCode;\r
- #endif\r
-\r
- while(_streamPos != _pos)\r
- {\r
- HRESULT result = FlushPart();\r
- if (result != S_OK)\r
- return result;\r
- }\r
- return S_OK;\r
-}\r
-\r
-void COutBuffer::FlushWithCheck()\r
-{\r
- HRESULT result = FlushPart();\r
- #ifdef _NO_EXCEPTIONS\r
- ErrorCode = result;\r
- #else\r
- if (result != S_OK)\r
- throw COutBufferException(result);\r
- #endif\r
-}\r
+++ /dev/null
-// OutBuffer.h\r
-\r
-#ifndef __OUTBUFFER_H\r
-#define __OUTBUFFER_H\r
-\r
-#include "../IStream.h"\r
-#include "../../Common/MyCom.h"\r
-\r
-#ifndef _NO_EXCEPTIONS\r
-struct COutBufferException\r
-{\r
- HRESULT ErrorCode;\r
- COutBufferException(HRESULT errorCode): ErrorCode(errorCode) {}\r
-};\r
-#endif\r
-\r
-class COutBuffer\r
-{\r
-protected:\r
- Byte *_buffer;\r
- UInt32 _pos;\r
- UInt32 _limitPos;\r
- UInt32 _streamPos;\r
- UInt32 _bufferSize;\r
- CMyComPtr<ISequentialOutStream> _stream;\r
- UInt64 _processedSize;\r
- Byte *_buffer2;\r
- bool _overDict;\r
-\r
- HRESULT FlushPart();\r
- void FlushWithCheck();\r
-public:\r
- #ifdef _NO_EXCEPTIONS\r
- HRESULT ErrorCode;\r
- #endif\r
-\r
- COutBuffer(): _buffer(0), _pos(0), _stream(0), _buffer2(0) {}\r
- ~COutBuffer() { Free(); }\r
- \r
- bool Create(UInt32 bufferSize);\r
- void Free();\r
-\r
- void SetMemStream(Byte *buffer) { _buffer2 = buffer; }\r
- void SetStream(ISequentialOutStream *stream);\r
- void Init();\r
- HRESULT Flush();\r
- void ReleaseStream() { _stream.Release(); }\r
-\r
- void WriteByte(Byte b)\r
- {\r
- _buffer[_pos++] = b;\r
- if(_pos == _limitPos)\r
- FlushWithCheck();\r
- }\r
- void WriteBytes(const void *data, size_t size)\r
- {\r
- for (size_t i = 0; i < size; i++)\r
- WriteByte(((const Byte *)data)[i]);\r
- }\r
-\r
- UInt64 GetProcessedSize() const;\r
-};\r
-\r
-#endif\r
+++ /dev/null
-// StdAfx.h\r
-\r
-#ifndef __STDAFX_H\r
-#define __STDAFX_H\r
-\r
-#include "../../Common/MyWindows.h"\r
-#include "../../Common/NewHandler.h"\r
-\r
-#endif \r
+++ /dev/null
-// StreamUtils.cpp\r
-\r
-#include "StdAfx.h"\r
-\r
-#include "../../Common/MyCom.h"\r
-#include "StreamUtils.h"\r
-\r
-HRESULT ReadStream(ISequentialInStream *stream, void *data, UInt32 size, UInt32 *processedSize)\r
-{\r
- if (processedSize != 0)\r
- *processedSize = 0;\r
- while(size != 0)\r
- {\r
- UInt32 processedSizeLoc; \r
- HRESULT res = stream->Read(data, size, &processedSizeLoc);\r
- if (processedSize != 0)\r
- *processedSize += processedSizeLoc;\r
- data = (Byte *)((Byte *)data + processedSizeLoc);\r
- size -= processedSizeLoc;\r
- RINOK(res);\r
- if (processedSizeLoc == 0)\r
- return S_OK;\r
- }\r
- return S_OK;\r
-}\r
-\r
-HRESULT WriteStream(ISequentialOutStream *stream, const void *data, UInt32 size, UInt32 *processedSize)\r
-{\r
- if (processedSize != 0)\r
- *processedSize = 0;\r
- while(size != 0)\r
- {\r
- UInt32 processedSizeLoc; \r
- HRESULT res = stream->Write(data, size, &processedSizeLoc);\r
- if (processedSize != 0)\r
- *processedSize += processedSizeLoc;\r
- data = (const void *)((const Byte *)data + processedSizeLoc);\r
- size -= processedSizeLoc;\r
- RINOK(res);\r
- if (processedSizeLoc == 0)\r
- break;\r
- }\r
- return S_OK;\r
-}\r
+++ /dev/null
-// StreamUtils.h\r
-\r
-#ifndef __STREAMUTILS_H\r
-#define __STREAMUTILS_H\r
-\r
-#include "../IStream.h"\r
-\r
-HRESULT ReadStream(ISequentialInStream *stream, void *data, UInt32 size, UInt32 *processedSize);\r
-HRESULT WriteStream(ISequentialOutStream *stream, const void *data, UInt32 size, UInt32 *processedSize);\r
-\r
-#endif\r
+++ /dev/null
-// BinTree.h\r
-\r
-#include "../LZInWindow.h"\r
-#include "../IMatchFinder.h"\r
- \r
-namespace BT_NAMESPACE {\r
-\r
-typedef UInt32 CIndex;\r
-const UInt32 kMaxValForNormalize = (UInt32(1) << 31) - 1;\r
-\r
-class CMatchFinder: \r
- public IMatchFinder,\r
- public CLZInWindow,\r
- public CMyUnknownImp,\r
- public IMatchFinderSetNumPasses\r
-{\r
- UInt32 _cyclicBufferPos;\r
- UInt32 _cyclicBufferSize; // it must be historySize + 1\r
- UInt32 _matchMaxLen;\r
- CIndex *_hash;\r
- CIndex *_son;\r
- UInt32 _hashMask;\r
- UInt32 _cutValue;\r
- UInt32 _hashSizeSum;\r
-\r
- void Normalize();\r
- void FreeThisClassMemory();\r
- void FreeMemory();\r
-\r
- MY_UNKNOWN_IMP\r
-\r
- STDMETHOD(SetStream)(ISequentialInStream *inStream);\r
- STDMETHOD_(void, ReleaseStream)();\r
- STDMETHOD(Init)();\r
- HRESULT MovePos();\r
- STDMETHOD_(Byte, GetIndexByte)(Int32 index);\r
- STDMETHOD_(UInt32, GetMatchLen)(Int32 index, UInt32 back, UInt32 limit);\r
- STDMETHOD_(UInt32, GetNumAvailableBytes)();\r
- STDMETHOD_(const Byte *, GetPointerToCurrentPos)();\r
- STDMETHOD_(Int32, NeedChangeBufferPos)(UInt32 numCheckBytes);\r
- STDMETHOD_(void, ChangeBufferPos)();\r
-\r
- STDMETHOD(Create)(UInt32 historySize, UInt32 keepAddBufferBefore, \r
- UInt32 matchMaxLen, UInt32 keepAddBufferAfter);\r
- STDMETHOD(GetMatches)(UInt32 *distances);\r
- STDMETHOD(Skip)(UInt32 num);\r
-\r
-public:\r
- CMatchFinder();\r
- virtual ~CMatchFinder();\r
- virtual void SetNumPasses(UInt32 numPasses) { _cutValue = numPasses; }\r
-};\r
-\r
-}\r
+++ /dev/null
-// BinTree2.h\r
-\r
-#ifndef __BINTREE2_H\r
-#define __BINTREE2_H\r
-\r
-#define BT_NAMESPACE NBT2\r
-\r
-#include "BinTreeMain.h"\r
-\r
-#undef BT_NAMESPACE\r
-\r
-#endif\r
+++ /dev/null
-// BinTree3.h\r
-\r
-#ifndef __BINTREE3_H\r
-#define __BINTREE3_H\r
-\r
-#define BT_NAMESPACE NBT3\r
-\r
-#define HASH_ARRAY_2\r
-\r
-#include "BinTreeMain.h"\r
-\r
-#undef HASH_ARRAY_2\r
-\r
-#undef BT_NAMESPACE\r
-\r
-#endif\r
+++ /dev/null
-// BinTree4.h\r
-\r
-#ifndef __BINTREE4_H\r
-#define __BINTREE4_H\r
-\r
-#define BT_NAMESPACE NBT4\r
-\r
-#define HASH_ARRAY_2\r
-#define HASH_ARRAY_3\r
-\r
-#include "BinTreeMain.h"\r
-\r
-#undef HASH_ARRAY_2\r
-#undef HASH_ARRAY_3\r
-\r
-#undef BT_NAMESPACE\r
-\r
-#endif\r
+++ /dev/null
-// BinTreeMain.h\r
-\r
-#include "../../../../Common/Defs.h"\r
-#include "../../../../Common/CRC.h"\r
-#include "../../../../Common/Alloc.h"\r
-\r
-#include "BinTree.h"\r
-\r
-// #include <xmmintrin.h>\r
-// It's for prefetch\r
-// But prefetch doesn't give big gain in K8.\r
-\r
-namespace BT_NAMESPACE {\r
-\r
-#ifdef HASH_ARRAY_2\r
- static const UInt32 kHash2Size = 1 << 10;\r
- #define kNumHashDirectBytes 0\r
- #ifdef HASH_ARRAY_3\r
- static const UInt32 kNumHashBytes = 4;\r
- static const UInt32 kHash3Size = 1 << 16;\r
- #else\r
- static const UInt32 kNumHashBytes = 3;\r
- #endif\r
- static const UInt32 kHashSize = 0;\r
- static const UInt32 kMinMatchCheck = kNumHashBytes;\r
- static const UInt32 kStartMaxLen = 1;\r
-#else\r
- #ifdef HASH_ZIP \r
- #define kNumHashDirectBytes 0\r
- static const UInt32 kNumHashBytes = 3;\r
- static const UInt32 kHashSize = 1 << 16;\r
- static const UInt32 kMinMatchCheck = kNumHashBytes;\r
- static const UInt32 kStartMaxLen = 1;\r
- #else\r
- #define kNumHashDirectBytes 2\r
- static const UInt32 kNumHashBytes = 2;\r
- static const UInt32 kHashSize = 1 << (8 * kNumHashBytes);\r
- static const UInt32 kMinMatchCheck = kNumHashBytes + 1;\r
- static const UInt32 kStartMaxLen = 1;\r
- #endif\r
-#endif\r
-\r
-#ifdef HASH_ARRAY_2\r
-#ifdef HASH_ARRAY_3\r
-static const UInt32 kHash3Offset = kHash2Size;\r
-#endif\r
-#endif\r
-\r
-static const UInt32 kFixHashSize = 0\r
- #ifdef HASH_ARRAY_2\r
- + kHash2Size\r
- #ifdef HASH_ARRAY_3\r
- + kHash3Size\r
- #endif\r
- #endif\r
- ;\r
-\r
-CMatchFinder::CMatchFinder():\r
- _hash(0)\r
-{\r
-}\r
-\r
-void CMatchFinder::FreeThisClassMemory()\r
-{\r
- BigFree(_hash);\r
- _hash = 0;\r
-}\r
-\r
-void CMatchFinder::FreeMemory()\r
-{\r
- FreeThisClassMemory();\r
- CLZInWindow::Free();\r
-}\r
-\r
-CMatchFinder::~CMatchFinder()\r
-{ \r
- FreeMemory();\r
-}\r
-\r
-STDMETHODIMP CMatchFinder::Create(UInt32 historySize, UInt32 keepAddBufferBefore, \r
- UInt32 matchMaxLen, UInt32 keepAddBufferAfter)\r
-{\r
- if (historySize > kMaxValForNormalize - 256)\r
- {\r
- FreeMemory();\r
- return E_INVALIDARG;\r
- }\r
- _cutValue = \r
- #ifdef _HASH_CHAIN\r
- 8 + (matchMaxLen >> 2);\r
- #else\r
- 16 + (matchMaxLen >> 1);\r
- #endif\r
- UInt32 sizeReserv = (historySize + keepAddBufferBefore + \r
- matchMaxLen + keepAddBufferAfter) / 2 + 256;\r
- if (CLZInWindow::Create(historySize + keepAddBufferBefore, \r
- matchMaxLen + keepAddBufferAfter, sizeReserv))\r
- {\r
- _matchMaxLen = matchMaxLen;\r
- UInt32 newCyclicBufferSize = historySize + 1;\r
- if (_hash != 0 && newCyclicBufferSize == _cyclicBufferSize)\r
- return S_OK;\r
- FreeThisClassMemory();\r
- _cyclicBufferSize = newCyclicBufferSize; // don't change it\r
-\r
- UInt32 hs = kHashSize;\r
-\r
- #ifdef HASH_ARRAY_2\r
- hs = historySize - 1;\r
- hs |= (hs >> 1);\r
- hs |= (hs >> 2);\r
- hs |= (hs >> 4);\r
- hs |= (hs >> 8);\r
- hs >>= 1;\r
- hs |= 0xFFFF;\r
- if (hs > (1 << 24))\r
- {\r
- #ifdef HASH_ARRAY_3\r
- hs >>= 1;\r
- #else\r
- hs = (1 << 24) - 1;\r
- #endif\r
- }\r
- _hashMask = hs;\r
- hs++;\r
- #endif\r
- _hashSizeSum = hs + kFixHashSize;\r
- UInt32 numItems = _hashSizeSum + _cyclicBufferSize\r
- #ifndef _HASH_CHAIN\r
- * 2\r
- #endif\r
- ;\r
- size_t sizeInBytes = (size_t)numItems * sizeof(CIndex);\r
- if (sizeInBytes / sizeof(CIndex) != numItems)\r
- return E_OUTOFMEMORY;\r
- _hash = (CIndex *)BigAlloc(sizeInBytes);\r
- _son = _hash + _hashSizeSum;\r
- if (_hash != 0)\r
- return S_OK;\r
- }\r
- FreeMemory();\r
- return E_OUTOFMEMORY;\r
-}\r
-\r
-static const UInt32 kEmptyHashValue = 0;\r
-\r
-STDMETHODIMP CMatchFinder::SetStream(ISequentialInStream *stream)\r
-{\r
- CLZInWindow::SetStream(stream);\r
- return S_OK;\r
-}\r
-\r
-STDMETHODIMP CMatchFinder::Init()\r
-{\r
- RINOK(CLZInWindow::Init());\r
- for(UInt32 i = 0; i < _hashSizeSum; i++)\r
- _hash[i] = kEmptyHashValue;\r
- _cyclicBufferPos = 0;\r
- ReduceOffsets(-1);\r
- return S_OK;\r
-}\r
-\r
-STDMETHODIMP_(void) CMatchFinder::ReleaseStream()\r
-{ \r
- // ReleaseStream(); \r
-}\r
-\r
-#ifdef HASH_ARRAY_2\r
-#ifdef HASH_ARRAY_3\r
-\r
-#define HASH_CALC { \\r
- UInt32 temp = CCRC::Table[cur[0]] ^ cur[1]; \\r
- hash2Value = temp & (kHash2Size - 1); \\r
- hash3Value = (temp ^ (UInt32(cur[2]) << 8)) & (kHash3Size - 1); \\r
- hashValue = (temp ^ (UInt32(cur[2]) << 8) ^ (CCRC::Table[cur[3]] << 5)) & _hashMask; }\r
- \r
-#else // no HASH_ARRAY_3\r
-#define HASH_CALC { \\r
- UInt32 temp = CCRC::Table[cur[0]] ^ cur[1]; \\r
- hash2Value = temp & (kHash2Size - 1); \\r
- hashValue = (temp ^ (UInt32(cur[2]) << 8)) & _hashMask; }\r
-#endif // HASH_ARRAY_3\r
-#else // no HASH_ARRAY_2\r
-#ifdef HASH_ZIP \r
-inline UInt32 Hash(const Byte *pointer)\r
-{\r
- return ((UInt32(pointer[0]) << 8) ^ CCRC::Table[pointer[1]] ^ pointer[2]) & (kHashSize - 1);\r
-}\r
-#else // no HASH_ZIP \r
-inline UInt32 Hash(const Byte *pointer)\r
-{\r
- return pointer[0] ^ (UInt32(pointer[1]) << 8);\r
-}\r
-#endif // HASH_ZIP\r
-#endif // HASH_ARRAY_2\r
-\r
-STDMETHODIMP CMatchFinder::GetMatches(UInt32 *distances)\r
-{\r
- UInt32 lenLimit;\r
- if (_pos + _matchMaxLen <= _streamPos)\r
- lenLimit = _matchMaxLen;\r
- else\r
- {\r
- lenLimit = _streamPos - _pos;\r
- if(lenLimit < kMinMatchCheck)\r
- {\r
- distances[0] = 0;\r
- return MovePos(); \r
- }\r
- }\r
-\r
- int offset = 1;\r
-\r
- UInt32 matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;\r
- const Byte *cur = _buffer + _pos;\r
-\r
- UInt32 maxLen = kStartMaxLen; // to avoid items for len < hashSize;\r
-\r
- #ifdef HASH_ARRAY_2\r
- UInt32 hash2Value;\r
- #ifdef HASH_ARRAY_3\r
- UInt32 hash3Value;\r
- #endif\r
- UInt32 hashValue;\r
- HASH_CALC;\r
- #else\r
- UInt32 hashValue = Hash(cur);\r
- #endif\r
-\r
- UInt32 curMatch = _hash[kFixHashSize + hashValue];\r
- #ifdef HASH_ARRAY_2\r
- UInt32 curMatch2 = _hash[hash2Value];\r
- #ifdef HASH_ARRAY_3\r
- UInt32 curMatch3 = _hash[kHash3Offset + hash3Value];\r
- #endif\r
- _hash[hash2Value] = _pos;\r
- if(curMatch2 > matchMinPos)\r
- if (_buffer[curMatch2] == cur[0])\r
- {\r
- distances[offset++] = maxLen = 2;\r
- distances[offset++] = _pos - curMatch2 - 1;\r
- }\r
-\r
- #ifdef HASH_ARRAY_3\r
- _hash[kHash3Offset + hash3Value] = _pos;\r
- if(curMatch3 > matchMinPos)\r
- if (_buffer[curMatch3] == cur[0])\r
- {\r
- if (curMatch3 == curMatch2)\r
- offset -= 2;\r
- distances[offset++] = maxLen = 3;\r
- distances[offset++] = _pos - curMatch3 - 1;\r
- curMatch2 = curMatch3;\r
- }\r
- #endif\r
- if (offset != 1 && curMatch2 == curMatch)\r
- {\r
- offset -= 2;\r
- maxLen = kStartMaxLen;\r
- }\r
- #endif\r
-\r
- _hash[kFixHashSize + hashValue] = _pos;\r
-\r
- CIndex *son = _son;\r
-\r
- #ifdef _HASH_CHAIN\r
- son[_cyclicBufferPos] = curMatch;\r
- #else\r
- CIndex *ptr0 = son + (_cyclicBufferPos << 1) + 1;\r
- CIndex *ptr1 = son + (_cyclicBufferPos << 1);\r
-\r
- UInt32 len0, len1;\r
- len0 = len1 = kNumHashDirectBytes;\r
- #endif\r
-\r
- #if kNumHashDirectBytes != 0\r
- if(curMatch > matchMinPos)\r
- {\r
- if (_buffer[curMatch + kNumHashDirectBytes] != cur[kNumHashDirectBytes])\r
- {\r
- distances[offset++] = maxLen = kNumHashDirectBytes;\r
- distances[offset++] = _pos - curMatch - 1;\r
- }\r
- }\r
- #endif\r
- UInt32 count = _cutValue;\r
- while(true)\r
- {\r
- if(curMatch <= matchMinPos || count-- == 0)\r
- {\r
- #ifndef _HASH_CHAIN\r
- *ptr0 = *ptr1 = kEmptyHashValue;\r
- #endif\r
- break;\r
- }\r
- UInt32 delta = _pos - curMatch;\r
- UInt32 cyclicPos = (delta <= _cyclicBufferPos) ?\r
- (_cyclicBufferPos - delta):\r
- (_cyclicBufferPos - delta + _cyclicBufferSize);\r
- CIndex *pair = son + \r
- #ifdef _HASH_CHAIN\r
- cyclicPos;\r
- #else\r
- (cyclicPos << 1);\r
- #endif\r
- \r
- // _mm_prefetch((const char *)pair, _MM_HINT_T0);\r
- \r
- const Byte *pb = _buffer + curMatch;\r
- UInt32 len = \r
- #ifdef _HASH_CHAIN\r
- kNumHashDirectBytes;\r
- if (pb[maxLen] == cur[maxLen])\r
- #else\r
- MyMin(len0, len1);\r
- #endif\r
- if (pb[len] == cur[len])\r
- {\r
- while(++len != lenLimit)\r
- if (pb[len] != cur[len])\r
- break;\r
- if (maxLen < len)\r
- {\r
- distances[offset++] = maxLen = len;\r
- distances[offset++] = delta - 1;\r
- if (len == lenLimit)\r
- {\r
- #ifndef _HASH_CHAIN\r
- *ptr1 = pair[0];\r
- *ptr0 = pair[1];\r
- #endif\r
- break;\r
- }\r
- }\r
- }\r
- #ifdef _HASH_CHAIN\r
- curMatch = *pair;\r
- #else\r
- if (pb[len] < cur[len])\r
- {\r
- *ptr1 = curMatch;\r
- ptr1 = pair + 1;\r
- curMatch = *ptr1;\r
- len1 = len;\r
- }\r
- else\r
- {\r
- *ptr0 = curMatch;\r
- ptr0 = pair;\r
- curMatch = *ptr0;\r
- len0 = len;\r
- }\r
- #endif\r
- }\r
- distances[0] = offset - 1;\r
- if (++_cyclicBufferPos == _cyclicBufferSize)\r
- _cyclicBufferPos = 0;\r
- RINOK(CLZInWindow::MovePos());\r
- if (_pos == kMaxValForNormalize)\r
- Normalize();\r
- return S_OK;\r
-}\r
-\r
-STDMETHODIMP CMatchFinder::Skip(UInt32 num)\r
-{\r
- do\r
- {\r
- #ifdef _HASH_CHAIN\r
- if (_streamPos - _pos < kNumHashBytes)\r
- {\r
- RINOK(MovePos()); \r
- continue;\r
- }\r
- #else\r
- UInt32 lenLimit;\r
- if (_pos + _matchMaxLen <= _streamPos)\r
- lenLimit = _matchMaxLen;\r
- else\r
- {\r
- lenLimit = _streamPos - _pos;\r
- if(lenLimit < kMinMatchCheck)\r
- {\r
- RINOK(MovePos());\r
- continue;\r
- }\r
- }\r
- UInt32 matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;\r
- #endif\r
- const Byte *cur = _buffer + _pos;\r
-\r
- #ifdef HASH_ARRAY_2\r
- UInt32 hash2Value;\r
- #ifdef HASH_ARRAY_3\r
- UInt32 hash3Value;\r
- UInt32 hashValue;\r
- HASH_CALC;\r
- _hash[kHash3Offset + hash3Value] = _pos;\r
- #else\r
- UInt32 hashValue;\r
- HASH_CALC;\r
- #endif\r
- _hash[hash2Value] = _pos;\r
- #else\r
- UInt32 hashValue = Hash(cur);\r
- #endif\r
-\r
- UInt32 curMatch = _hash[kFixHashSize + hashValue];\r
- _hash[kFixHashSize + hashValue] = _pos;\r
-\r
- #ifdef _HASH_CHAIN\r
- _son[_cyclicBufferPos] = curMatch;\r
- #else\r
- CIndex *son = _son;\r
- CIndex *ptr0 = son + (_cyclicBufferPos << 1) + 1;\r
- CIndex *ptr1 = son + (_cyclicBufferPos << 1);\r
-\r
- UInt32 len0, len1;\r
- len0 = len1 = kNumHashDirectBytes;\r
- UInt32 count = _cutValue;\r
- while(true)\r
- {\r
- if(curMatch <= matchMinPos || count-- == 0)\r
- {\r
- *ptr0 = *ptr1 = kEmptyHashValue;\r
- break;\r
- }\r
- \r
- UInt32 delta = _pos - curMatch;\r
- UInt32 cyclicPos = (delta <= _cyclicBufferPos) ?\r
- (_cyclicBufferPos - delta):\r
- (_cyclicBufferPos - delta + _cyclicBufferSize);\r
- CIndex *pair = son + (cyclicPos << 1);\r
- \r
- // _mm_prefetch((const char *)pair, _MM_HINT_T0);\r
- \r
- const Byte *pb = _buffer + curMatch;\r
- UInt32 len = MyMin(len0, len1);\r
- \r
- if (pb[len] == cur[len])\r
- {\r
- while(++len != lenLimit)\r
- if (pb[len] != cur[len])\r
- break;\r
- if (len == lenLimit)\r
- {\r
- *ptr1 = pair[0];\r
- *ptr0 = pair[1];\r
- break;\r
- }\r
- }\r
- if (pb[len] < cur[len])\r
- {\r
- *ptr1 = curMatch;\r
- ptr1 = pair + 1;\r
- curMatch = *ptr1;\r
- len1 = len;\r
- }\r
- else\r
- {\r
- *ptr0 = curMatch;\r
- ptr0 = pair;\r
- curMatch = *ptr0;\r
- len0 = len;\r
- }\r
- }\r
- #endif\r
- if (++_cyclicBufferPos == _cyclicBufferSize)\r
- _cyclicBufferPos = 0;\r
- RINOK(CLZInWindow::MovePos());\r
- if (_pos == kMaxValForNormalize)\r
- Normalize();\r
- }\r
- while(--num != 0);\r
- return S_OK;\r
-}\r
-\r
-void CMatchFinder::Normalize()\r
-{\r
- UInt32 subValue = _pos - _cyclicBufferSize;\r
- CIndex *items = _hash;\r
- UInt32 numItems = (_hashSizeSum + _cyclicBufferSize \r
- #ifndef _HASH_CHAIN\r
- * 2\r
- #endif\r
- );\r
- for (UInt32 i = 0; i < numItems; i++)\r
- {\r
- UInt32 value = items[i];\r
- if (value <= subValue)\r
- value = kEmptyHashValue;\r
- else\r
- value -= subValue;\r
- items[i] = value;\r
- }\r
- ReduceOffsets(subValue);\r
-}\r
-\r
-HRESULT CMatchFinder::MovePos()\r
-{\r
- if (++_cyclicBufferPos == _cyclicBufferSize)\r
- _cyclicBufferPos = 0;\r
- RINOK(CLZInWindow::MovePos());\r
- if (_pos == kMaxValForNormalize)\r
- Normalize();\r
- return S_OK;\r
-}\r
-\r
-STDMETHODIMP_(Byte) CMatchFinder::GetIndexByte(Int32 index)\r
- { return CLZInWindow::GetIndexByte(index); }\r
-\r
-STDMETHODIMP_(UInt32) CMatchFinder::GetMatchLen(Int32 index, \r
- UInt32 back, UInt32 limit)\r
- { return CLZInWindow::GetMatchLen(index, back, limit); }\r
-\r
-STDMETHODIMP_(UInt32) CMatchFinder::GetNumAvailableBytes()\r
- { return CLZInWindow::GetNumAvailableBytes(); }\r
-\r
-STDMETHODIMP_(const Byte *) CMatchFinder::GetPointerToCurrentPos()\r
- { return CLZInWindow::GetPointerToCurrentPos(); }\r
-\r
-STDMETHODIMP_(Int32) CMatchFinder::NeedChangeBufferPos(UInt32 numCheckBytes)\r
- { return CLZInWindow::NeedMove(numCheckBytes) ? 1: 0; }\r
-\r
-STDMETHODIMP_(void) CMatchFinder::ChangeBufferPos()\r
- { CLZInWindow::MoveBlock();}\r
-\r
-#undef HASH_CALC\r
-#undef kNumHashDirectBytes\r
- \r
-}\r
+++ /dev/null
-// HC4.h\r
-\r
-#ifndef __HC4_H\r
-#define __HC4_H\r
-\r
-#define BT_NAMESPACE NHC4\r
-\r
-#define HASH_ARRAY_2\r
-#define HASH_ARRAY_3\r
-\r
-#include "HCMain.h"\r
-\r
-#undef HASH_ARRAY_2\r
-#undef HASH_ARRAY_3\r
-\r
-#undef BT_NAMESPACE\r
-\r
-#endif\r
-\r
+++ /dev/null
-// HCMain.h\r
-\r
-#define _HASH_CHAIN\r
-#include "../BinTree/BinTreeMain.h"\r
-#undef _HASH_CHAIN\r
-\r
+++ /dev/null
-// MatchFinders/IMatchFinder.h\r
-\r
-#ifndef __IMATCHFINDER_H\r
-#define __IMATCHFINDER_H\r
-\r
-struct IInWindowStream: public IUnknown\r
-{\r
- STDMETHOD(SetStream)(ISequentialInStream *inStream) PURE;\r
- STDMETHOD_(void, ReleaseStream)() PURE;\r
- STDMETHOD(Init)() PURE;\r
- STDMETHOD_(Byte, GetIndexByte)(Int32 index) PURE;\r
- STDMETHOD_(UInt32, GetMatchLen)(Int32 index, UInt32 distance, UInt32 limit) PURE;\r
- STDMETHOD_(UInt32, GetNumAvailableBytes)() PURE;\r
- STDMETHOD_(const Byte *, GetPointerToCurrentPos)() PURE;\r
- STDMETHOD_(Int32, NeedChangeBufferPos)(UInt32 numCheckBytes) PURE;\r
- STDMETHOD_(void, ChangeBufferPos)() PURE;\r
-};\r
- \r
-struct IMatchFinder: public IInWindowStream\r
-{\r
- STDMETHOD(Create)(UInt32 historySize, UInt32 keepAddBufferBefore, \r
- UInt32 matchMaxLen, UInt32 keepAddBufferAfter) PURE;\r
- STDMETHOD(GetMatches)(UInt32 *distances) PURE;\r
- STDMETHOD(Skip)(UInt32 num) PURE;\r
-};\r
-\r
-struct IMatchFinderSetNumPasses\r
-{\r
- //virtual ~IMatchFinderSetNumPasses(){}\r
- virtual void SetNumPasses(UInt32 numPasses) PURE;\r
-};\r
-\r
-#endif\r
+++ /dev/null
-// LZInWindow.cpp\r
-\r
-#include "StdAfx.h"\r
-\r
-#include "LZInWindow.h"\r
-#include "../../../Common/MyCom.h"\r
-#include "../../../Common/Alloc.h"\r
-\r
-void CLZInWindow::Free()\r
-{\r
- ::BigFree(_bufferBase);\r
- _bufferBase = 0;\r
-}\r
-\r
-bool CLZInWindow::Create(UInt32 keepSizeBefore, UInt32 keepSizeAfter, UInt32 keepSizeReserv)\r
-{\r
- _keepSizeBefore = keepSizeBefore;\r
- _keepSizeAfter = keepSizeAfter;\r
- UInt32 blockSize = keepSizeBefore + keepSizeAfter + keepSizeReserv;\r
- if (_bufferBase == 0 || _blockSize != blockSize)\r
- {\r
- Free();\r
- _blockSize = blockSize;\r
- if (_blockSize != 0)\r
- _bufferBase = (Byte *)::BigAlloc(_blockSize);\r
- }\r
- _pointerToLastSafePosition = _bufferBase + _blockSize - keepSizeAfter;\r
- if (_blockSize == 0)\r
- return true;\r
- return (_bufferBase != 0);\r
-}\r
-\r
-void CLZInWindow::SetStream(ISequentialInStream *stream)\r
-{\r
- _stream = stream;\r
-}\r
-\r
-HRESULT CLZInWindow::Init()\r
-{\r
- _buffer = _bufferBase;\r
- _pos = 0;\r
- _streamPos = 0;\r
- _streamEndWasReached = false;\r
- return ReadBlock();\r
-}\r
-\r
-/*\r
-void CLZInWindow::ReleaseStream()\r
-{\r
- _stream.Release();\r
-}\r
-*/\r
-\r
-///////////////////////////////////////////\r
-// ReadBlock\r
-\r
-// In State:\r
-// (_buffer + _streamPos) <= (_bufferBase + _blockSize)\r
-// Out State:\r
-// _posLimit <= _blockSize - _keepSizeAfter;\r
-// if(_streamEndWasReached == false):\r
-// _streamPos >= _pos + _keepSizeAfter\r
-// _posLimit = _streamPos - _keepSizeAfter;\r
-// else\r
-// \r
- \r
-HRESULT CLZInWindow::ReadBlock()\r
-{\r
- if(_streamEndWasReached)\r
- return S_OK;\r
- while(true)\r
- {\r
- UInt32 size = (UInt32)(_bufferBase - _buffer) + _blockSize - _streamPos;\r
- if(size == 0)\r
- return S_OK;\r
- UInt32 numReadBytes;\r
- RINOK(_stream->Read(_buffer + _streamPos, size, &numReadBytes));\r
- if(numReadBytes == 0)\r
- {\r
- _posLimit = _streamPos;\r
- const Byte *pointerToPostion = _buffer + _posLimit;\r
- if(pointerToPostion > _pointerToLastSafePosition)\r
- _posLimit = (UInt32)(_pointerToLastSafePosition - _buffer);\r
- _streamEndWasReached = true;\r
- return S_OK;\r
- }\r
- _streamPos += numReadBytes;\r
- if(_streamPos >= _pos + _keepSizeAfter)\r
- {\r
- _posLimit = _streamPos - _keepSizeAfter;\r
- return S_OK;\r
- }\r
- }\r
-}\r
-\r
-void CLZInWindow::MoveBlock()\r
-{\r
- UInt32 offset = (UInt32)(_buffer - _bufferBase) + _pos - _keepSizeBefore;\r
- // we need one additional byte, since MovePos moves on 1 byte.\r
- if (offset > 0)\r
- offset--; \r
- UInt32 numBytes = (UInt32)(_buffer - _bufferBase) + _streamPos - offset;\r
- memmove(_bufferBase, _bufferBase + offset, numBytes);\r
- _buffer -= offset;\r
-}\r
+++ /dev/null
-// LZInWindow.h\r
-\r
-#ifndef __LZ_IN_WINDOW_H\r
-#define __LZ_IN_WINDOW_H\r
-\r
-#include "../../IStream.h"\r
-\r
-class CLZInWindow\r
-{\r
- Byte *_bufferBase; // pointer to buffer with data\r
- ISequentialInStream *_stream;\r
- UInt32 _posLimit; // offset (from _buffer) when new block reading must be done\r
- bool _streamEndWasReached; // if (true) then _streamPos shows real end of stream\r
- const Byte *_pointerToLastSafePosition;\r
-protected:\r
- Byte *_buffer; // Pointer to virtual Buffer begin\r
- UInt32 _blockSize; // Size of Allocated memory block\r
- UInt32 _pos; // offset (from _buffer) of curent byte\r
- UInt32 _keepSizeBefore; // how many BYTEs must be kept in buffer before _pos\r
- UInt32 _keepSizeAfter; // how many BYTEs must be kept buffer after _pos\r
- UInt32 _streamPos; // offset (from _buffer) of first not read byte from Stream\r
-\r
- void MoveBlock();\r
- HRESULT ReadBlock();\r
- void Free();\r
-public:\r
- CLZInWindow(): _bufferBase(0) {}\r
- virtual ~CLZInWindow() { Free(); }\r
-\r
- // keepSizeBefore + keepSizeAfter + keepSizeReserv < 4G)\r
- bool Create(UInt32 keepSizeBefore, UInt32 keepSizeAfter, UInt32 keepSizeReserv = (1<<17));\r
-\r
- void SetStream(ISequentialInStream *stream);\r
- HRESULT Init();\r
- // void ReleaseStream();\r
-\r
- Byte *GetBuffer() const { return _buffer; }\r
-\r
- const Byte *GetPointerToCurrentPos() const { return _buffer + _pos; }\r
-\r
- HRESULT MovePos()\r
- {\r
- _pos++;\r
- if (_pos > _posLimit)\r
- {\r
- const Byte *pointerToPostion = _buffer + _pos;\r
- if(pointerToPostion > _pointerToLastSafePosition)\r
- MoveBlock();\r
- return ReadBlock();\r
- }\r
- else\r
- return S_OK;\r
- }\r
- Byte GetIndexByte(Int32 index) const { return _buffer[(size_t)_pos + index]; }\r
-\r
- // index + limit have not to exceed _keepSizeAfter;\r
- // -2G <= index < 2G\r
- UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit) const\r
- { \r
- if(_streamEndWasReached)\r
- if ((_pos + index) + limit > _streamPos)\r
- limit = _streamPos - (_pos + index);\r
- distance++;\r
- const Byte *pby = _buffer + (size_t)_pos + index;\r
- UInt32 i;\r
- for(i = 0; i < limit && pby[i] == pby[(size_t)i - distance]; i++);\r
- return i;\r
- }\r
-\r
- UInt32 GetNumAvailableBytes() const { return _streamPos - _pos; }\r
-\r
- void ReduceOffsets(Int32 subValue)\r
- {\r
- _buffer += subValue;\r
- _posLimit -= subValue;\r
- _pos -= subValue;\r
- _streamPos -= subValue;\r
- }\r
-\r
- bool NeedMove(UInt32 numCheckBytes)\r
- {\r
- UInt32 reserv = _pointerToLastSafePosition - (_buffer + _pos);\r
- return (reserv <= numCheckBytes);\r
- }\r
-};\r
-\r
-#endif\r
+++ /dev/null
-// StdAfx.h\r
-\r
-#ifndef __STDAFX_H\r
-#define __STDAFX_H\r
-\r
-#endif \r
+++ /dev/null
-// LZMA.h\r
-\r
-#ifndef __LZMA_H\r
-#define __LZMA_H\r
-\r
-namespace NCompress {\r
-namespace NLZMA {\r
-\r
-const UInt32 kNumRepDistances = 4;\r
-\r
-const int kNumStates = 12;\r
-\r
-const Byte kLiteralNextStates[kNumStates] = {0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 4, 5};\r
-const Byte kMatchNextStates[kNumStates] = {7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10};\r
-const Byte kRepNextStates[kNumStates] = {8, 8, 8, 8, 8, 8, 8, 11, 11, 11, 11, 11};\r
-const Byte kShortRepNextStates[kNumStates]= {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11};\r
-\r
-class CState\r
-{\r
-public:\r
- Byte Index;\r
- void Init() { Index = 0; }\r
- void UpdateChar() { Index = kLiteralNextStates[Index]; }\r
- void UpdateMatch() { Index = kMatchNextStates[Index]; }\r
- void UpdateRep() { Index = kRepNextStates[Index]; }\r
- void UpdateShortRep() { Index = kShortRepNextStates[Index]; }\r
- bool IsCharState() const { return Index < 7; }\r
-};\r
-\r
-const int kNumPosSlotBits = 6; \r
-const int kDicLogSizeMin = 0; \r
-const int kDicLogSizeMax = 32; \r
-const int kDistTableSizeMax = kDicLogSizeMax * 2; \r
-\r
-const UInt32 kNumLenToPosStates = 4;\r
-\r
-inline UInt32 GetLenToPosState(UInt32 len)\r
-{\r
- len -= 2;\r
- if (len < kNumLenToPosStates)\r
- return len;\r
- return kNumLenToPosStates - 1;\r
-}\r
-\r
-namespace NLength {\r
-\r
-const int kNumPosStatesBitsMax = 4;\r
-const UInt32 kNumPosStatesMax = (1 << kNumPosStatesBitsMax);\r
-\r
-const int kNumPosStatesBitsEncodingMax = 4;\r
-const UInt32 kNumPosStatesEncodingMax = (1 << kNumPosStatesBitsEncodingMax);\r
-\r
-const int kNumLowBits = 3;\r
-const int kNumMidBits = 3;\r
-const int kNumHighBits = 8;\r
-const UInt32 kNumLowSymbols = 1 << kNumLowBits;\r
-const UInt32 kNumMidSymbols = 1 << kNumMidBits;\r
-const UInt32 kNumSymbolsTotal = kNumLowSymbols + kNumMidSymbols + (1 << kNumHighBits);\r
-\r
-}\r
-\r
-const UInt32 kMatchMinLen = 2;\r
-const UInt32 kMatchMaxLen = kMatchMinLen + NLength::kNumSymbolsTotal - 1;\r
-\r
-const int kNumAlignBits = 4;\r
-const UInt32 kAlignTableSize = 1 << kNumAlignBits;\r
-const UInt32 kAlignMask = (kAlignTableSize - 1);\r
-\r
-const UInt32 kStartPosModelIndex = 4;\r
-const UInt32 kEndPosModelIndex = 14;\r
-const UInt32 kNumPosModels = kEndPosModelIndex - kStartPosModelIndex;\r
-\r
-const UInt32 kNumFullDistances = 1 << (kEndPosModelIndex / 2);\r
-\r
-const int kNumLitPosStatesBitsEncodingMax = 4;\r
-const int kNumLitContextBitsMax = 8;\r
-\r
-const int kNumMoveBits = 5;\r
-\r
-}}\r
-\r
-#endif\r
+++ /dev/null
-// LZMA/Encoder.cpp\r
-\r
-#include "StdAfx.h"\r
-\r
-#include "../../../Common/Defs.h"\r
-#include "../../Common/StreamUtils.h"\r
-\r
-#include "LZMAEncoder.h"\r
-\r
-// for minimal compressing code size define these:\r
-// #define COMPRESS_MF_BT\r
-// #define COMPRESS_MF_BT4\r
-\r
-#if !defined(COMPRESS_MF_BT) && !defined(COMPRESS_MF_HC)\r
-#define COMPRESS_MF_BT\r
-#define COMPRESS_MF_HC\r
-#endif\r
-\r
-#ifdef COMPRESS_MF_BT\r
-#if !defined(COMPRESS_MF_BT2) && !defined(COMPRESS_MF_BT3) && !defined(COMPRESS_MF_BT4)\r
-#define COMPRESS_MF_BT2\r
-#define COMPRESS_MF_BT3\r
-#define COMPRESS_MF_BT4\r
-#endif\r
-#ifdef COMPRESS_MF_BT2\r
-#include "../LZ/BinTree/BinTree2.h"\r
-#endif\r
-#ifdef COMPRESS_MF_BT3\r
-#include "../LZ/BinTree/BinTree3.h"\r
-#endif\r
-#ifdef COMPRESS_MF_BT4\r
-#include "../LZ/BinTree/BinTree4.h"\r
-#endif\r
-#endif\r
-\r
-#ifdef COMPRESS_MF_HC\r
-#include "../LZ/HashChain/HC4.h"\r
-#endif\r
-\r
-#ifdef COMPRESS_MF_MT\r
-#include "../LZ/MT/MT.h"\r
-#endif\r
-\r
-namespace NCompress {\r
-namespace NLZMA {\r
-\r
-const int kDefaultDictionaryLogSize = 22;\r
-const UInt32 kNumFastBytesDefault = 0x20;\r
-\r
-enum \r
-{\r
- kBT2,\r
- kBT3,\r
- kBT4,\r
- kHC4\r
-};\r
-\r
-static const wchar_t *kMatchFinderIDs[] = \r
-{\r
- L"BT2",\r
- L"BT3",\r
- L"BT4",\r
- L"HC4"\r
-};\r
-\r
-Byte g_FastPos[1 << 11];\r
-\r
-class CFastPosInit\r
-{\r
-public:\r
- CFastPosInit() { Init(); }\r
- void Init()\r
- {\r
- const Byte kFastSlots = 22;\r
- int c = 2;\r
- g_FastPos[0] = 0;\r
- g_FastPos[1] = 1;\r
-\r
- for (Byte slotFast = 2; slotFast < kFastSlots; slotFast++)\r
- {\r
- UInt32 k = (1 << ((slotFast >> 1) - 1));\r
- for (UInt32 j = 0; j < k; j++, c++)\r
- g_FastPos[c] = slotFast;\r
- }\r
- }\r
-} g_FastPosInit;\r
-\r
-\r
-void CLiteralEncoder2::Encode(NRangeCoder::CEncoder *rangeEncoder, Byte symbol)\r
-{\r
- UInt32 context = 1;\r
- int i = 8;\r
- do \r
- {\r
- i--;\r
- UInt32 bit = (symbol >> i) & 1;\r
- _encoders[context].Encode(rangeEncoder, bit);\r
- context = (context << 1) | bit;\r
- }\r
- while(i != 0);\r
-}\r
-\r
-void CLiteralEncoder2::EncodeMatched(NRangeCoder::CEncoder *rangeEncoder, \r
- Byte matchByte, Byte symbol)\r
-{\r
- UInt32 context = 1;\r
- int i = 8;\r
- do \r
- {\r
- i--;\r
- UInt32 bit = (symbol >> i) & 1;\r
- UInt32 matchBit = (matchByte >> i) & 1;\r
- _encoders[0x100 + (matchBit << 8) + context].Encode(rangeEncoder, bit);\r
- context = (context << 1) | bit;\r
- if (matchBit != bit)\r
- {\r
- while(i != 0)\r
- {\r
- i--;\r
- UInt32 bit = (symbol >> i) & 1;\r
- _encoders[context].Encode(rangeEncoder, bit);\r
- context = (context << 1) | bit;\r
- }\r
- break;\r
- }\r
- }\r
- while(i != 0);\r
-}\r
-\r
-UInt32 CLiteralEncoder2::GetPrice(bool matchMode, Byte matchByte, Byte symbol) const\r
-{\r
- UInt32 price = 0;\r
- UInt32 context = 1;\r
- int i = 8;\r
- if (matchMode)\r
- {\r
- do \r
- {\r
- i--;\r
- UInt32 matchBit = (matchByte >> i) & 1;\r
- UInt32 bit = (symbol >> i) & 1;\r
- price += _encoders[0x100 + (matchBit << 8) + context].GetPrice(bit);\r
- context = (context << 1) | bit;\r
- if (matchBit != bit)\r
- break;\r
- }\r
- while (i != 0);\r
- }\r
- while(i != 0)\r
- {\r
- i--;\r
- UInt32 bit = (symbol >> i) & 1;\r
- price += _encoders[context].GetPrice(bit);\r
- context = (context << 1) | bit;\r
- }\r
- return price;\r
-};\r
-\r
-\r
-namespace NLength {\r
-\r
-void CEncoder::Init(UInt32 numPosStates)\r
-{\r
- _choice.Init();\r
- _choice2.Init();\r
- for (UInt32 posState = 0; posState < numPosStates; posState++)\r
- {\r
- _lowCoder[posState].Init();\r
- _midCoder[posState].Init();\r
- }\r
- _highCoder.Init();\r
-}\r
-\r
-void CEncoder::Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 symbol, UInt32 posState)\r
-{\r
- if(symbol < kNumLowSymbols)\r
- {\r
- _choice.Encode(rangeEncoder, 0);\r
- _lowCoder[posState].Encode(rangeEncoder, symbol);\r
- }\r
- else\r
- {\r
- _choice.Encode(rangeEncoder, 1);\r
- if(symbol < kNumLowSymbols + kNumMidSymbols)\r
- {\r
- _choice2.Encode(rangeEncoder, 0);\r
- _midCoder[posState].Encode(rangeEncoder, symbol - kNumLowSymbols);\r
- }\r
- else\r
- {\r
- _choice2.Encode(rangeEncoder, 1);\r
- _highCoder.Encode(rangeEncoder, symbol - kNumLowSymbols - kNumMidSymbols);\r
- }\r
- }\r
-}\r
-\r
-void CEncoder::SetPrices(UInt32 posState, UInt32 numSymbols, UInt32 *prices) const\r
-{\r
- UInt32 a0 = _choice.GetPrice0();\r
- UInt32 a1 = _choice.GetPrice1();\r
- UInt32 b0 = a1 + _choice2.GetPrice0();\r
- UInt32 b1 = a1 + _choice2.GetPrice1();\r
- UInt32 i = 0;\r
- for (i = 0; i < kNumLowSymbols; i++)\r
- {\r
- if (i >= numSymbols)\r
- return;\r
- prices[i] = a0 + _lowCoder[posState].GetPrice(i);\r
- }\r
- for (; i < kNumLowSymbols + kNumMidSymbols; i++)\r
- {\r
- if (i >= numSymbols)\r
- return;\r
- prices[i] = b0 + _midCoder[posState].GetPrice(i - kNumLowSymbols);\r
- }\r
- for (; i < numSymbols; i++)\r
- prices[i] = b1 + _highCoder.GetPrice(i - kNumLowSymbols - kNumMidSymbols);\r
-}\r
-\r
-}\r
-CEncoder::CEncoder():\r
- _numFastBytes(kNumFastBytesDefault),\r
- _distTableSize(kDefaultDictionaryLogSize * 2),\r
- _posStateBits(2),\r
- _posStateMask(4 - 1),\r
- _numLiteralPosStateBits(0),\r
- _numLiteralContextBits(3),\r
- _dictionarySize(1 << kDefaultDictionaryLogSize),\r
- _dictionarySizePrev(UInt32(-1)),\r
- _numFastBytesPrev(UInt32(-1)),\r
- _matchFinderCycles(0),\r
- _matchFinderIndex(kBT4),\r
- #ifdef COMPRESS_MF_MT\r
- _multiThread(false),\r
- #endif\r
- _writeEndMark(false),\r
- setMfPasses(0)\r
-{\r
- // _maxMode = false;\r
- _fastMode = false;\r
-}\r
-\r
-HRESULT CEncoder::Create()\r
-{\r
- if (!_rangeEncoder.Create(1 << 20))\r
- return E_OUTOFMEMORY;\r
- if (!_matchFinder)\r
- {\r
- switch(_matchFinderIndex)\r
- {\r
- #ifdef COMPRESS_MF_BT\r
- #ifdef COMPRESS_MF_BT2\r
- case kBT2:\r
- {\r
- NBT2::CMatchFinder *mfSpec = new NBT2::CMatchFinder;\r
- setMfPasses = mfSpec;\r
- _matchFinder = mfSpec;\r
- break;\r
- }\r
- #endif\r
- #ifdef COMPRESS_MF_BT3\r
- case kBT3:\r
- {\r
- NBT3::CMatchFinder *mfSpec = new NBT3::CMatchFinder;\r
- setMfPasses = mfSpec;\r
- _matchFinder = mfSpec;\r
- break;\r
- }\r
- #endif\r
- #ifdef COMPRESS_MF_BT4\r
- case kBT4:\r
- {\r
- NBT4::CMatchFinder *mfSpec = new NBT4::CMatchFinder;\r
- setMfPasses = mfSpec;\r
- _matchFinder = mfSpec;\r
- break;\r
- }\r
- #endif\r
- #endif\r
- \r
- #ifdef COMPRESS_MF_HC\r
- case kHC4:\r
- {\r
- NHC4::CMatchFinder *mfSpec = new NHC4::CMatchFinder;\r
- setMfPasses = mfSpec;\r
- _matchFinder = mfSpec;\r
- break;\r
- }\r
- #endif\r
- }\r
- if (_matchFinder == 0)\r
- return E_OUTOFMEMORY;\r
-\r
- #ifdef COMPRESS_MF_MT\r
- if (_multiThread && !(_fastMode && (_matchFinderIndex == kHC4)))\r
- {\r
- CMatchFinderMT *mfSpec = new CMatchFinderMT;\r
- if (mfSpec == 0)\r
- return E_OUTOFMEMORY;\r
- CMyComPtr<IMatchFinder> mf = mfSpec;\r
- RINOK(mfSpec->SetMatchFinder(_matchFinder));\r
- _matchFinder.Release();\r
- _matchFinder = mf;\r
- }\r
- #endif\r
- }\r
- \r
- if (!_literalEncoder.Create(_numLiteralPosStateBits, _numLiteralContextBits))\r
- return E_OUTOFMEMORY;\r
-\r
- if (_dictionarySize == _dictionarySizePrev && _numFastBytesPrev == _numFastBytes)\r
- return S_OK;\r
- RINOK(_matchFinder->Create(_dictionarySize, kNumOpts, _numFastBytes, kMatchMaxLen + 1)); // actually it's + _numFastBytes - _numFastBytes\r
- if (_matchFinderCycles != 0 && setMfPasses != 0)\r
- setMfPasses->SetNumPasses(_matchFinderCycles);\r
- _dictionarySizePrev = _dictionarySize;\r
- _numFastBytesPrev = _numFastBytes;\r
- return S_OK;\r
-}\r
-\r
-static bool AreStringsEqual(const wchar_t *base, const wchar_t *testString)\r
-{\r
- while (true)\r
- {\r
- wchar_t c = *testString;\r
- if (c >= 'a' && c <= 'z')\r
- c -= 0x20;\r
- if (*base != c)\r
- return false;\r
- if (c == 0)\r
- return true;\r
- base++;\r
- testString++;\r
- }\r
-}\r
-\r
-static int FindMatchFinder(const wchar_t *s)\r
-{\r
- for (int m = 0; m < (int)(sizeof(kMatchFinderIDs) / sizeof(kMatchFinderIDs[0])); m++)\r
- if (AreStringsEqual(kMatchFinderIDs[m], s))\r
- return m;\r
- return -1;\r
-}\r
-\r
-STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs, \r
- const PROPVARIANT *properties, UInt32 numProperties)\r
-{\r
- for (UInt32 i = 0; i < numProperties; i++)\r
- {\r
- const PROPVARIANT &prop = properties[i];\r
- switch(propIDs[i])\r
- {\r
- case NCoderPropID::kNumFastBytes:\r
- {\r
- if (prop.vt != VT_UI4)\r
- return E_INVALIDARG;\r
- UInt32 numFastBytes = prop.ulVal;\r
- if(numFastBytes < 5 || numFastBytes > kMatchMaxLen)\r
- return E_INVALIDARG;\r
- _numFastBytes = numFastBytes;\r
- break;\r
- }\r
- case NCoderPropID::kMatchFinderCycles:\r
- {\r
- if (prop.vt != VT_UI4)\r
- return E_INVALIDARG;\r
- _matchFinderCycles = prop.ulVal;\r
- break;\r
- }\r
- case NCoderPropID::kAlgorithm:\r
- {\r
- if (prop.vt != VT_UI4)\r
- return E_INVALIDARG;\r
- UInt32 maximize = prop.ulVal;\r
- _fastMode = (maximize == 0); \r
- // _maxMode = (maximize >= 2);\r
- break;\r
- }\r
- case NCoderPropID::kMatchFinder:\r
- {\r
- if (prop.vt != VT_BSTR)\r
- return E_INVALIDARG;\r
- int matchFinderIndexPrev = _matchFinderIndex;\r
- int m = FindMatchFinder(prop.bstrVal);\r
- if (m < 0)\r
- return E_INVALIDARG;\r
- _matchFinderIndex = m;\r
- if (_matchFinder && matchFinderIndexPrev != _matchFinderIndex)\r
- {\r
- _dictionarySizePrev = (UInt32)-1;\r
- ReleaseMatchFinder();\r
- }\r
- break;\r
- }\r
- #ifdef COMPRESS_MF_MT\r
- case NCoderPropID::kMultiThread:\r
- {\r
- if (prop.vt != VT_BOOL)\r
- return E_INVALIDARG;\r
- bool newMultiThread = (prop.boolVal == VARIANT_TRUE);\r
- if (newMultiThread != _multiThread)\r
- {\r
- _dictionarySizePrev = (UInt32)-1;\r
- ReleaseMatchFinder();\r
- _multiThread = newMultiThread;\r
- }\r
- break;\r
- }\r
- case NCoderPropID::kNumThreads:\r
- {\r
- if (prop.vt != VT_UI4)\r
- return E_INVALIDARG;\r
- bool newMultiThread = (prop.ulVal > 1);\r
- if (newMultiThread != _multiThread)\r
- {\r
- _dictionarySizePrev = (UInt32)-1;\r
- ReleaseMatchFinder();\r
- _multiThread = newMultiThread;\r
- }\r
- break;\r
- }\r
- #endif\r
- case NCoderPropID::kDictionarySize:\r
- {\r
- const int kDicLogSizeMaxCompress = 30;\r
- if (prop.vt != VT_UI4)\r
- return E_INVALIDARG;\r
- UInt32 dictionarySize = prop.ulVal;\r
- if (dictionarySize < UInt32(1 << kDicLogSizeMin) ||\r
- dictionarySize > UInt32(1 << kDicLogSizeMaxCompress))\r
- return E_INVALIDARG;\r
- _dictionarySize = dictionarySize;\r
- UInt32 dicLogSize;\r
- for(dicLogSize = 0; dicLogSize < (UInt32)kDicLogSizeMaxCompress; dicLogSize++)\r
- if (dictionarySize <= (UInt32(1) << dicLogSize))\r
- break;\r
- _distTableSize = dicLogSize * 2;\r
- break;\r
- }\r
- case NCoderPropID::kPosStateBits:\r
- {\r
- if (prop.vt != VT_UI4)\r
- return E_INVALIDARG;\r
- UInt32 value = prop.ulVal;\r
- if (value > (UInt32)NLength::kNumPosStatesBitsEncodingMax)\r
- return E_INVALIDARG;\r
- _posStateBits = value;\r
- _posStateMask = (1 << _posStateBits) - 1;\r
- break;\r
- }\r
- case NCoderPropID::kLitPosBits:\r
- {\r
- if (prop.vt != VT_UI4)\r
- return E_INVALIDARG;\r
- UInt32 value = prop.ulVal;\r
- if (value > (UInt32)kNumLitPosStatesBitsEncodingMax)\r
- return E_INVALIDARG;\r
- _numLiteralPosStateBits = value;\r
- break;\r
- }\r
- case NCoderPropID::kLitContextBits:\r
- {\r
- if (prop.vt != VT_UI4)\r
- return E_INVALIDARG;\r
- UInt32 value = prop.ulVal;\r
- if (value > (UInt32)kNumLitContextBitsMax)\r
- return E_INVALIDARG;\r
- _numLiteralContextBits = value;\r
- break;\r
- }\r
- case NCoderPropID::kEndMarker:\r
- {\r
- if (prop.vt != VT_BOOL)\r
- return E_INVALIDARG;\r
- SetWriteEndMarkerMode(prop.boolVal == VARIANT_TRUE);\r
- break;\r
- }\r
- default:\r
- return E_INVALIDARG;\r
- }\r
- }\r
- return S_OK;\r
-}\r
-\r
-STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream)\r
-{ \r
- const UInt32 kPropSize = 5;\r
- Byte properties[kPropSize];\r
- properties[0] = (_posStateBits * 5 + _numLiteralPosStateBits) * 9 + _numLiteralContextBits;\r
- for (int i = 0; i < 4; i++)\r
- properties[1 + i] = Byte(_dictionarySize >> (8 * i));\r
- return WriteStream(outStream, properties, kPropSize, NULL);\r
-}\r
-\r
-STDMETHODIMP CEncoder::SetOutStream(ISequentialOutStream *outStream)\r
-{\r
- _rangeEncoder.SetStream(outStream);\r
- return S_OK;\r
-}\r
-\r
-STDMETHODIMP CEncoder::ReleaseOutStream()\r
-{\r
- _rangeEncoder.ReleaseStream();\r
- return S_OK;\r
-}\r
-\r
-HRESULT CEncoder::Init()\r
-{\r
- CBaseState::Init();\r
-\r
- // RINOK(_matchFinder->Init(inStream));\r
- _rangeEncoder.Init();\r
-\r
- for(int i = 0; i < kNumStates; i++)\r
- {\r
- for (UInt32 j = 0; j <= _posStateMask; j++)\r
- {\r
- _isMatch[i][j].Init();\r
- _isRep0Long[i][j].Init();\r
- }\r
- _isRep[i].Init();\r
- _isRepG0[i].Init();\r
- _isRepG1[i].Init();\r
- _isRepG2[i].Init();\r
- }\r
-\r
- _literalEncoder.Init();\r
-\r
- {\r
- for(UInt32 i = 0; i < kNumLenToPosStates; i++)\r
- _posSlotEncoder[i].Init();\r
- }\r
- {\r
- for(UInt32 i = 0; i < kNumFullDistances - kEndPosModelIndex; i++)\r
- _posEncoders[i].Init();\r
- }\r
-\r
- _lenEncoder.Init(1 << _posStateBits);\r
- _repMatchLenEncoder.Init(1 << _posStateBits);\r
-\r
- _posAlignEncoder.Init();\r
-\r
- _longestMatchWasFound = false;\r
- _optimumEndIndex = 0;\r
- _optimumCurrentIndex = 0;\r
- _additionalOffset = 0;\r
-\r
- return S_OK;\r
-}\r
-\r
-HRESULT CEncoder::MovePos(UInt32 num)\r
-{\r
- if (num == 0)\r
- return S_OK;\r
- _additionalOffset += num;\r
- return _matchFinder->Skip(num);\r
-}\r
-\r
-UInt32 CEncoder::Backward(UInt32 &backRes, UInt32 cur)\r
-{\r
- _optimumEndIndex = cur;\r
- UInt32 posMem = _optimum[cur].PosPrev;\r
- UInt32 backMem = _optimum[cur].BackPrev;\r
- do\r
- {\r
- if (_optimum[cur].Prev1IsChar)\r
- {\r
- _optimum[posMem].MakeAsChar();\r
- _optimum[posMem].PosPrev = posMem - 1;\r
- if (_optimum[cur].Prev2)\r
- {\r
- _optimum[posMem - 1].Prev1IsChar = false;\r
- _optimum[posMem - 1].PosPrev = _optimum[cur].PosPrev2;\r
- _optimum[posMem - 1].BackPrev = _optimum[cur].BackPrev2;\r
- }\r
- }\r
- UInt32 posPrev = posMem;\r
- UInt32 backCur = backMem;\r
-\r
- backMem = _optimum[posPrev].BackPrev;\r
- posMem = _optimum[posPrev].PosPrev;\r
-\r
- _optimum[posPrev].BackPrev = backCur;\r
- _optimum[posPrev].PosPrev = cur;\r
- cur = posPrev;\r
- }\r
- while(cur != 0);\r
- backRes = _optimum[0].BackPrev;\r
- _optimumCurrentIndex = _optimum[0].PosPrev;\r
- return _optimumCurrentIndex; \r
-}\r
-\r
-/*\r
-Out:\r
- (lenRes == 1) && (backRes == 0xFFFFFFFF) means Literal\r
-*/\r
-\r
-HRESULT CEncoder::GetOptimum(UInt32 position, UInt32 &backRes, UInt32 &lenRes)\r
-{\r
- if(_optimumEndIndex != _optimumCurrentIndex)\r
- {\r
- const COptimal &optimum = _optimum[_optimumCurrentIndex];\r
- lenRes = optimum.PosPrev - _optimumCurrentIndex;\r
- backRes = optimum.BackPrev;\r
- _optimumCurrentIndex = optimum.PosPrev;\r
- return S_OK;\r
- }\r
- _optimumCurrentIndex = _optimumEndIndex = 0;\r
- \r
- UInt32 lenMain, numDistancePairs;\r
- if (!_longestMatchWasFound)\r
- {\r
- RINOK(ReadMatchDistances(lenMain, numDistancePairs));\r
- }\r
- else\r
- {\r
- lenMain = _longestMatchLength;\r
- numDistancePairs = _numDistancePairs;\r
- _longestMatchWasFound = false;\r
- }\r
-\r
- const Byte *data = _matchFinder->GetPointerToCurrentPos() - 1;\r
- UInt32 numAvailableBytes = _matchFinder->GetNumAvailableBytes() + 1;\r
- if (numAvailableBytes < 2)\r
- {\r
- backRes = (UInt32)(-1);\r
- lenRes = 1;\r
- return S_OK;\r
- }\r
- if (numAvailableBytes > kMatchMaxLen)\r
- numAvailableBytes = kMatchMaxLen;\r
-\r
- UInt32 reps[kNumRepDistances];\r
- UInt32 repLens[kNumRepDistances];\r
- UInt32 repMaxIndex = 0;\r
- UInt32 i;\r
- for(i = 0; i < kNumRepDistances; i++)\r
- {\r
- reps[i] = _repDistances[i];\r
- UInt32 backOffset = reps[i] + 1;\r
- if (data[0] != data[(size_t)0 - backOffset] || data[1] != data[(size_t)1 - backOffset])\r
- {\r
- repLens[i] = 0;\r
- continue;\r
- }\r
- UInt32 lenTest;\r
- for (lenTest = 2; lenTest < numAvailableBytes && \r
- data[lenTest] == data[(size_t)lenTest - backOffset]; lenTest++);\r
- repLens[i] = lenTest;\r
- if (lenTest > repLens[repMaxIndex])\r
- repMaxIndex = i;\r
- }\r
- if(repLens[repMaxIndex] >= _numFastBytes)\r
- {\r
- backRes = repMaxIndex;\r
- lenRes = repLens[repMaxIndex];\r
- return MovePos(lenRes - 1);\r
- }\r
-\r
- UInt32 *matchDistances = _matchDistances + 1;\r
- if(lenMain >= _numFastBytes)\r
- {\r
- backRes = matchDistances[numDistancePairs - 1] + kNumRepDistances; \r
- lenRes = lenMain;\r
- return MovePos(lenMain - 1);\r
- }\r
- Byte currentByte = *data;\r
- Byte matchByte = data[(size_t)0 - reps[0] - 1];\r
-\r
- if(lenMain < 2 && currentByte != matchByte && repLens[repMaxIndex] < 2)\r
- {\r
- backRes = (UInt32)-1;\r
- lenRes = 1;\r
- return S_OK;\r
- }\r
-\r
- _optimum[0].State = _state;\r
-\r
- UInt32 posState = (position & _posStateMask);\r
-\r
- _optimum[1].Price = _isMatch[_state.Index][posState].GetPrice0() + \r
- _literalEncoder.GetSubCoder(position, _previousByte)->GetPrice(!_state.IsCharState(), matchByte, currentByte);\r
- _optimum[1].MakeAsChar();\r
-\r
- UInt32 matchPrice = _isMatch[_state.Index][posState].GetPrice1();\r
- UInt32 repMatchPrice = matchPrice + _isRep[_state.Index].GetPrice1();\r
-\r
- if(matchByte == currentByte)\r
- {\r
- UInt32 shortRepPrice = repMatchPrice + GetRepLen1Price(_state, posState);\r
- if(shortRepPrice < _optimum[1].Price)\r
- {\r
- _optimum[1].Price = shortRepPrice;\r
- _optimum[1].MakeAsShortRep();\r
- }\r
- }\r
- UInt32 lenEnd = ((lenMain >= repLens[repMaxIndex]) ? lenMain : repLens[repMaxIndex]);\r
-\r
- if(lenEnd < 2)\r
- {\r
- backRes = _optimum[1].BackPrev;\r
- lenRes = 1;\r
- return S_OK;\r
- }\r
-\r
- _optimum[1].PosPrev = 0;\r
- for (i = 0; i < kNumRepDistances; i++)\r
- _optimum[0].Backs[i] = reps[i];\r
-\r
- UInt32 len = lenEnd;\r
- do\r
- _optimum[len--].Price = kIfinityPrice;\r
- while (len >= 2);\r
-\r
- for(i = 0; i < kNumRepDistances; i++)\r
- {\r
- UInt32 repLen = repLens[i];\r
- if (repLen < 2)\r
- continue;\r
- UInt32 price = repMatchPrice + GetPureRepPrice(i, _state, posState);\r
- do\r
- {\r
- UInt32 curAndLenPrice = price + _repMatchLenEncoder.GetPrice(repLen - 2, posState);\r
- COptimal &optimum = _optimum[repLen];\r
- if (curAndLenPrice < optimum.Price) \r
- {\r
- optimum.Price = curAndLenPrice;\r
- optimum.PosPrev = 0;\r
- optimum.BackPrev = i;\r
- optimum.Prev1IsChar = false;\r
- }\r
- }\r
- while(--repLen >= 2);\r
- }\r
-\r
- UInt32 normalMatchPrice = matchPrice + _isRep[_state.Index].GetPrice0();\r
-\r
- len = ((repLens[0] >= 2) ? repLens[0] + 1 : 2);\r
- if (len <= lenMain)\r
- {\r
- UInt32 offs = 0;\r
- while (len > matchDistances[offs])\r
- offs += 2;\r
- for(; ; len++)\r
- {\r
- UInt32 distance = matchDistances[offs + 1];\r
- UInt32 curAndLenPrice = normalMatchPrice + GetPosLenPrice(distance, len, posState);\r
- COptimal &optimum = _optimum[len];\r
- if (curAndLenPrice < optimum.Price) \r
- {\r
- optimum.Price = curAndLenPrice;\r
- optimum.PosPrev = 0;\r
- optimum.BackPrev = distance + kNumRepDistances;\r
- optimum.Prev1IsChar = false;\r
- }\r
- if (len == matchDistances[offs])\r
- {\r
- offs += 2;\r
- if (offs == numDistancePairs)\r
- break;\r
- }\r
- }\r
- }\r
-\r
- UInt32 cur = 0;\r
-\r
- while(true)\r
- {\r
- cur++;\r
- if(cur == lenEnd)\r
- {\r
- lenRes = Backward(backRes, cur);\r
- return S_OK;\r
- }\r
- UInt32 newLen, numDistancePairs;\r
- RINOK(ReadMatchDistances(newLen, numDistancePairs));\r
- if(newLen >= _numFastBytes)\r
- {\r
- _numDistancePairs = numDistancePairs;\r
- _longestMatchLength = newLen;\r
- _longestMatchWasFound = true;\r
- lenRes = Backward(backRes, cur);\r
- return S_OK;\r
- }\r
- position++;\r
- COptimal &curOptimum = _optimum[cur];\r
- UInt32 posPrev = curOptimum.PosPrev;\r
- CState state;\r
- if (curOptimum.Prev1IsChar)\r
- {\r
- posPrev--;\r
- if (curOptimum.Prev2)\r
- {\r
- state = _optimum[curOptimum.PosPrev2].State;\r
- if (curOptimum.BackPrev2 < kNumRepDistances)\r
- state.UpdateRep();\r
- else\r
- state.UpdateMatch();\r
- }\r
- else\r
- state = _optimum[posPrev].State;\r
- state.UpdateChar();\r
- }\r
- else\r
- state = _optimum[posPrev].State;\r
- if (posPrev == cur - 1)\r
- {\r
- if (curOptimum.IsShortRep())\r
- state.UpdateShortRep();\r
- else\r
- state.UpdateChar();\r
- }\r
- else\r
- {\r
- UInt32 pos;\r
- if (curOptimum.Prev1IsChar && curOptimum.Prev2)\r
- {\r
- posPrev = curOptimum.PosPrev2;\r
- pos = curOptimum.BackPrev2;\r
- state.UpdateRep();\r
- }\r
- else\r
- {\r
- pos = curOptimum.BackPrev;\r
- if (pos < kNumRepDistances)\r
- state.UpdateRep();\r
- else\r
- state.UpdateMatch();\r
- }\r
- const COptimal &prevOptimum = _optimum[posPrev];\r
- if (pos < kNumRepDistances)\r
- {\r
- reps[0] = prevOptimum.Backs[pos];\r
- UInt32 i;\r
- for(i = 1; i <= pos; i++)\r
- reps[i] = prevOptimum.Backs[i - 1];\r
- for(; i < kNumRepDistances; i++)\r
- reps[i] = prevOptimum.Backs[i];\r
- }\r
- else\r
- {\r
- reps[0] = (pos - kNumRepDistances);\r
- for(UInt32 i = 1; i < kNumRepDistances; i++)\r
- reps[i] = prevOptimum.Backs[i - 1];\r
- }\r
- }\r
- curOptimum.State = state;\r
- for(UInt32 i = 0; i < kNumRepDistances; i++)\r
- curOptimum.Backs[i] = reps[i];\r
- UInt32 curPrice = curOptimum.Price; \r
- const Byte *data = _matchFinder->GetPointerToCurrentPos() - 1;\r
- const Byte currentByte = *data;\r
- const Byte matchByte = data[(size_t)0 - reps[0] - 1];\r
-\r
- UInt32 posState = (position & _posStateMask);\r
-\r
- UInt32 curAnd1Price = curPrice +\r
- _isMatch[state.Index][posState].GetPrice0() +\r
- _literalEncoder.GetSubCoder(position, data[(size_t)0 - 1])->GetPrice(!state.IsCharState(), matchByte, currentByte);\r
-\r
- COptimal &nextOptimum = _optimum[cur + 1];\r
-\r
- bool nextIsChar = false;\r
- if (curAnd1Price < nextOptimum.Price) \r
- {\r
- nextOptimum.Price = curAnd1Price;\r
- nextOptimum.PosPrev = cur;\r
- nextOptimum.MakeAsChar();\r
- nextIsChar = true;\r
- }\r
-\r
- UInt32 matchPrice = curPrice + _isMatch[state.Index][posState].GetPrice1();\r
- UInt32 repMatchPrice = matchPrice + _isRep[state.Index].GetPrice1();\r
- \r
- if(matchByte == currentByte &&\r
- !(nextOptimum.PosPrev < cur && nextOptimum.BackPrev == 0))\r
- {\r
- UInt32 shortRepPrice = repMatchPrice + GetRepLen1Price(state, posState);\r
- if(shortRepPrice <= nextOptimum.Price)\r
- {\r
- nextOptimum.Price = shortRepPrice;\r
- nextOptimum.PosPrev = cur;\r
- nextOptimum.MakeAsShortRep();\r
- nextIsChar = true;\r
- }\r
- }\r
- /*\r
- if(newLen == 2 && matchDistances[2] >= kDistLimit2) // test it maybe set 2000 ?\r
- continue;\r
- */\r
-\r
- UInt32 numAvailableBytesFull = _matchFinder->GetNumAvailableBytes() + 1;\r
- numAvailableBytesFull = MyMin(kNumOpts - 1 - cur, numAvailableBytesFull);\r
- UInt32 numAvailableBytes = numAvailableBytesFull;\r
-\r
- if (numAvailableBytes < 2)\r
- continue;\r
- if (numAvailableBytes > _numFastBytes)\r
- numAvailableBytes = _numFastBytes;\r
- if (!nextIsChar && matchByte != currentByte) // speed optimization\r
- {\r
- // try Literal + rep0\r
- UInt32 backOffset = reps[0] + 1;\r
- UInt32 limit = MyMin(numAvailableBytesFull, _numFastBytes + 1);\r
- UInt32 temp;\r
- for (temp = 1; temp < limit && \r
- data[temp] == data[(size_t)temp - backOffset]; temp++);\r
- UInt32 lenTest2 = temp - 1;\r
- if (lenTest2 >= 2)\r
- {\r
- CState state2 = state;\r
- state2.UpdateChar();\r
- UInt32 posStateNext = (position + 1) & _posStateMask;\r
- UInt32 nextRepMatchPrice = curAnd1Price + \r
- _isMatch[state2.Index][posStateNext].GetPrice1() +\r
- _isRep[state2.Index].GetPrice1();\r
- // for (; lenTest2 >= 2; lenTest2--)\r
- {\r
- UInt32 offset = cur + 1 + lenTest2;\r
- while(lenEnd < offset)\r
- _optimum[++lenEnd].Price = kIfinityPrice;\r
- UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(\r
- 0, lenTest2, state2, posStateNext);\r
- COptimal &optimum = _optimum[offset];\r
- if (curAndLenPrice < optimum.Price) \r
- {\r
- optimum.Price = curAndLenPrice;\r
- optimum.PosPrev = cur + 1;\r
- optimum.BackPrev = 0;\r
- optimum.Prev1IsChar = true;\r
- optimum.Prev2 = false;\r
- }\r
- }\r
- }\r
- }\r
- \r
- UInt32 startLen = 2; // speed optimization \r
- for(UInt32 repIndex = 0; repIndex < kNumRepDistances; repIndex++)\r
- {\r
- // UInt32 repLen = _matchFinder->GetMatchLen(0 - 1, reps[repIndex], newLen); // test it;\r
- UInt32 backOffset = reps[repIndex] + 1;\r
- if (data[0] != data[(size_t)0 - backOffset] ||\r
- data[1] != data[(size_t)1 - backOffset])\r
- continue;\r
- UInt32 lenTest;\r
- for (lenTest = 2; lenTest < numAvailableBytes && \r
- data[lenTest] == data[(size_t)lenTest - backOffset]; lenTest++);\r
- while(lenEnd < cur + lenTest)\r
- _optimum[++lenEnd].Price = kIfinityPrice;\r
- UInt32 lenTestTemp = lenTest;\r
- UInt32 price = repMatchPrice + GetPureRepPrice(repIndex, state, posState);\r
- do\r
- {\r
- UInt32 curAndLenPrice = price + _repMatchLenEncoder.GetPrice(lenTest - 2, posState);\r
- COptimal &optimum = _optimum[cur + lenTest];\r
- if (curAndLenPrice < optimum.Price) \r
- {\r
- optimum.Price = curAndLenPrice;\r
- optimum.PosPrev = cur;\r
- optimum.BackPrev = repIndex;\r
- optimum.Prev1IsChar = false;\r
- }\r
- }\r
- while(--lenTest >= 2);\r
- lenTest = lenTestTemp;\r
- \r
- if (repIndex == 0)\r
- startLen = lenTest + 1;\r
- \r
- // if (_maxMode)\r
- {\r
- UInt32 lenTest2 = lenTest + 1;\r
- UInt32 limit = MyMin(numAvailableBytesFull, lenTest2 + _numFastBytes);\r
- for (; lenTest2 < limit && \r
- data[lenTest2] == data[(size_t)lenTest2 - backOffset]; lenTest2++);\r
- lenTest2 -= lenTest + 1;\r
- if (lenTest2 >= 2)\r
- {\r
- CState state2 = state;\r
- state2.UpdateRep();\r
- UInt32 posStateNext = (position + lenTest) & _posStateMask;\r
- UInt32 curAndLenCharPrice = \r
- price + _repMatchLenEncoder.GetPrice(lenTest - 2, posState) + \r
- _isMatch[state2.Index][posStateNext].GetPrice0() +\r
- _literalEncoder.GetSubCoder(position + lenTest, data[(size_t)lenTest - 1])->GetPrice(\r
- true, data[(size_t)lenTest - backOffset], data[lenTest]);\r
- state2.UpdateChar();\r
- posStateNext = (position + lenTest + 1) & _posStateMask;\r
- UInt32 nextRepMatchPrice = curAndLenCharPrice + \r
- _isMatch[state2.Index][posStateNext].GetPrice1() +\r
- _isRep[state2.Index].GetPrice1();\r
- \r
- // for(; lenTest2 >= 2; lenTest2--)\r
- {\r
- UInt32 offset = cur + lenTest + 1 + lenTest2;\r
- while(lenEnd < offset)\r
- _optimum[++lenEnd].Price = kIfinityPrice;\r
- UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(\r
- 0, lenTest2, state2, posStateNext);\r
- COptimal &optimum = _optimum[offset];\r
- if (curAndLenPrice < optimum.Price) \r
- {\r
- optimum.Price = curAndLenPrice;\r
- optimum.PosPrev = cur + lenTest + 1;\r
- optimum.BackPrev = 0;\r
- optimum.Prev1IsChar = true;\r
- optimum.Prev2 = true;\r
- optimum.PosPrev2 = cur;\r
- optimum.BackPrev2 = repIndex;\r
- }\r
- }\r
- }\r
- }\r
- }\r
- \r
- // for(UInt32 lenTest = 2; lenTest <= newLen; lenTest++)\r
- if (newLen > numAvailableBytes)\r
- {\r
- newLen = numAvailableBytes;\r
- for (numDistancePairs = 0; newLen > matchDistances[numDistancePairs]; numDistancePairs += 2);\r
- matchDistances[numDistancePairs] = newLen;\r
- numDistancePairs += 2;\r
- }\r
- if (newLen >= startLen)\r
- {\r
- UInt32 normalMatchPrice = matchPrice + _isRep[state.Index].GetPrice0();\r
- while(lenEnd < cur + newLen)\r
- _optimum[++lenEnd].Price = kIfinityPrice;\r
-\r
- UInt32 offs = 0;\r
- while(startLen > matchDistances[offs])\r
- offs += 2;\r
- UInt32 curBack = matchDistances[offs + 1];\r
- UInt32 posSlot = GetPosSlot2(curBack);\r
- for(UInt32 lenTest = /*2*/ startLen; ; lenTest++)\r
- {\r
- UInt32 curAndLenPrice = normalMatchPrice;\r
- UInt32 lenToPosState = GetLenToPosState(lenTest);\r
- if (curBack < kNumFullDistances)\r
- curAndLenPrice += _distancesPrices[lenToPosState][curBack];\r
- else\r
- curAndLenPrice += _posSlotPrices[lenToPosState][posSlot] + _alignPrices[curBack & kAlignMask];\r
- \r
- curAndLenPrice += _lenEncoder.GetPrice(lenTest - kMatchMinLen, posState);\r
- \r
- COptimal &optimum = _optimum[cur + lenTest];\r
- if (curAndLenPrice < optimum.Price) \r
- {\r
- optimum.Price = curAndLenPrice;\r
- optimum.PosPrev = cur;\r
- optimum.BackPrev = curBack + kNumRepDistances;\r
- optimum.Prev1IsChar = false;\r
- }\r
-\r
- if (/*_maxMode && */lenTest == matchDistances[offs])\r
- {\r
- // Try Match + Literal + Rep0\r
- UInt32 backOffset = curBack + 1;\r
- UInt32 lenTest2 = lenTest + 1;\r
- UInt32 limit = MyMin(numAvailableBytesFull, lenTest2 + _numFastBytes);\r
- for (; lenTest2 < limit && \r
- data[lenTest2] == data[(size_t)lenTest2 - backOffset]; lenTest2++);\r
- lenTest2 -= lenTest + 1;\r
- if (lenTest2 >= 2)\r
- {\r
- CState state2 = state;\r
- state2.UpdateMatch();\r
- UInt32 posStateNext = (position + lenTest) & _posStateMask;\r
- UInt32 curAndLenCharPrice = curAndLenPrice + \r
- _isMatch[state2.Index][posStateNext].GetPrice0() +\r
- _literalEncoder.GetSubCoder(position + lenTest, data[(size_t)lenTest - 1])->GetPrice( \r
- true, data[(size_t)lenTest - backOffset], data[lenTest]);\r
- state2.UpdateChar();\r
- posStateNext = (posStateNext + 1) & _posStateMask;\r
- UInt32 nextRepMatchPrice = curAndLenCharPrice + \r
- _isMatch[state2.Index][posStateNext].GetPrice1() +\r
- _isRep[state2.Index].GetPrice1();\r
- \r
- // for(; lenTest2 >= 2; lenTest2--)\r
- {\r
- UInt32 offset = cur + lenTest + 1 + lenTest2;\r
- while(lenEnd < offset)\r
- _optimum[++lenEnd].Price = kIfinityPrice;\r
- UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(0, lenTest2, state2, posStateNext);\r
- COptimal &optimum = _optimum[offset];\r
- if (curAndLenPrice < optimum.Price) \r
- {\r
- optimum.Price = curAndLenPrice;\r
- optimum.PosPrev = cur + lenTest + 1;\r
- optimum.BackPrev = 0;\r
- optimum.Prev1IsChar = true;\r
- optimum.Prev2 = true;\r
- optimum.PosPrev2 = cur;\r
- optimum.BackPrev2 = curBack + kNumRepDistances;\r
- }\r
- }\r
- }\r
- offs += 2;\r
- if (offs == numDistancePairs)\r
- break;\r
- curBack = matchDistances[offs + 1];\r
- if (curBack >= kNumFullDistances)\r
- posSlot = GetPosSlot2(curBack);\r
- }\r
- }\r
- }\r
- }\r
-}\r
-\r
-static inline bool ChangePair(UInt32 smallDist, UInt32 bigDist)\r
-{\r
- return ((bigDist >> 7) > smallDist);\r
-}\r
-\r
-\r
-HRESULT CEncoder::ReadMatchDistances(UInt32 &lenRes, UInt32 &numDistancePairs)\r
-{\r
- lenRes = 0;\r
- RINOK(_matchFinder->GetMatches(_matchDistances));\r
- numDistancePairs = _matchDistances[0];\r
- if (numDistancePairs > 0)\r
- {\r
- lenRes = _matchDistances[1 + numDistancePairs - 2];\r
- if (lenRes == _numFastBytes)\r
- lenRes += _matchFinder->GetMatchLen(lenRes - 1, _matchDistances[1 + numDistancePairs - 1], \r
- kMatchMaxLen - lenRes);\r
- }\r
- _additionalOffset++;\r
- return S_OK;\r
-}\r
-\r
-HRESULT CEncoder::GetOptimumFast(UInt32 position, UInt32 &backRes, UInt32 &lenRes)\r
-{\r
- UInt32 lenMain, numDistancePairs;\r
- if (!_longestMatchWasFound)\r
- {\r
- RINOK(ReadMatchDistances(lenMain, numDistancePairs));\r
- }\r
- else\r
- {\r
- lenMain = _longestMatchLength;\r
- numDistancePairs = _numDistancePairs;\r
- _longestMatchWasFound = false;\r
- }\r
-\r
- const Byte *data = _matchFinder->GetPointerToCurrentPos() - 1;\r
- UInt32 numAvailableBytes = _matchFinder->GetNumAvailableBytes() + 1;\r
- if (numAvailableBytes > kMatchMaxLen)\r
- numAvailableBytes = kMatchMaxLen;\r
- if (numAvailableBytes < 2)\r
- {\r
- backRes = (UInt32)(-1);\r
- lenRes = 1;\r
- return S_OK;\r
- }\r
-\r
- UInt32 repLens[kNumRepDistances];\r
- UInt32 repMaxIndex = 0;\r
-\r
- for(UInt32 i = 0; i < kNumRepDistances; i++)\r
- {\r
- UInt32 backOffset = _repDistances[i] + 1;\r
- if (data[0] != data[(size_t)0 - backOffset] || data[1] != data[(size_t)1 - backOffset])\r
- {\r
- repLens[i] = 0;\r
- continue;\r
- }\r
- UInt32 len;\r
- for (len = 2; len < numAvailableBytes && data[len] == data[(size_t)len - backOffset]; len++);\r
- if(len >= _numFastBytes)\r
- {\r
- backRes = i;\r
- lenRes = len;\r
- return MovePos(lenRes - 1);\r
- }\r
- repLens[i] = len;\r
- if (len > repLens[repMaxIndex])\r
- repMaxIndex = i;\r
- }\r
- UInt32 *matchDistances = _matchDistances + 1;\r
- if(lenMain >= _numFastBytes)\r
- {\r
- backRes = matchDistances[numDistancePairs - 1] + kNumRepDistances; \r
- lenRes = lenMain;\r
- return MovePos(lenMain - 1);\r
- }\r
-\r
- UInt32 backMain = 0;\r
- if (lenMain >= 2)\r
- {\r
- backMain = matchDistances[numDistancePairs - 1];\r
- while (numDistancePairs > 2 && lenMain == matchDistances[numDistancePairs - 4] + 1)\r
- {\r
- if (!ChangePair(matchDistances[numDistancePairs - 3], backMain))\r
- break;\r
- numDistancePairs -= 2;\r
- lenMain = matchDistances[numDistancePairs - 2];\r
- backMain = matchDistances[numDistancePairs - 1];\r
- }\r
- if (lenMain == 2 && backMain >= 0x80)\r
- lenMain = 1;\r
- }\r
-\r
- if (repLens[repMaxIndex] >= 2)\r
- {\r
- if (repLens[repMaxIndex] + 1 >= lenMain || \r
- repLens[repMaxIndex] + 2 >= lenMain && (backMain > (1 << 9)) ||\r
- repLens[repMaxIndex] + 3 >= lenMain && (backMain > (1 << 15)))\r
- {\r
- backRes = repMaxIndex;\r
- lenRes = repLens[repMaxIndex];\r
- return MovePos(lenRes - 1);\r
- }\r
- }\r
- \r
- if (lenMain >= 2 && numAvailableBytes > 2)\r
- {\r
- RINOK(ReadMatchDistances(_longestMatchLength, _numDistancePairs));\r
- if (_longestMatchLength >= 2)\r
- {\r
- UInt32 newDistance = matchDistances[_numDistancePairs - 1];\r
- if (_longestMatchLength >= lenMain && newDistance < backMain || \r
- _longestMatchLength == lenMain + 1 && !ChangePair(backMain, newDistance) ||\r
- _longestMatchLength > lenMain + 1 ||\r
- _longestMatchLength + 1 >= lenMain && lenMain >= 3 && ChangePair(newDistance, backMain))\r
- {\r
- _longestMatchWasFound = true;\r
- backRes = UInt32(-1);\r
- lenRes = 1;\r
- return S_OK;\r
- }\r
- }\r
- data++;\r
- numAvailableBytes--;\r
- for(UInt32 i = 0; i < kNumRepDistances; i++)\r
- {\r
- UInt32 backOffset = _repDistances[i] + 1;\r
- if (data[1] != data[(size_t)1 - backOffset] || data[2] != data[(size_t)2 - backOffset])\r
- {\r
- repLens[i] = 0;\r
- continue;\r
- }\r
- UInt32 len;\r
- for (len = 2; len < numAvailableBytes && data[len] == data[(size_t)len - backOffset]; len++);\r
- if (len + 1 >= lenMain)\r
- {\r
- _longestMatchWasFound = true;\r
- backRes = UInt32(-1);\r
- lenRes = 1;\r
- return S_OK;\r
- }\r
- }\r
- backRes = backMain + kNumRepDistances; \r
- lenRes = lenMain;\r
- return MovePos(lenMain - 2);\r
- }\r
- backRes = UInt32(-1);\r
- lenRes = 1;\r
- return S_OK;\r
-}\r
-\r
-HRESULT CEncoder::Flush(UInt32 nowPos)\r
-{\r
- ReleaseMFStream();\r
- WriteEndMarker(nowPos & _posStateMask);\r
- _rangeEncoder.FlushData();\r
- return _rangeEncoder.FlushStream();\r
-}\r
-\r
-void CEncoder::WriteEndMarker(UInt32 posState)\r
-{\r
- // This function for writing End Mark for stream version of LZMA. \r
- // In current version this feature is not used.\r
- if (!_writeEndMark)\r
- return;\r
-\r
- _isMatch[_state.Index][posState].Encode(&_rangeEncoder, 1);\r
- _isRep[_state.Index].Encode(&_rangeEncoder, 0);\r
- _state.UpdateMatch();\r
- UInt32 len = kMatchMinLen; // kMatchMaxLen;\r
- _lenEncoder.Encode(&_rangeEncoder, len - kMatchMinLen, posState, !_fastMode);\r
- UInt32 posSlot = (1 << kNumPosSlotBits) - 1;\r
- UInt32 lenToPosState = GetLenToPosState(len);\r
- _posSlotEncoder[lenToPosState].Encode(&_rangeEncoder, posSlot);\r
- UInt32 footerBits = 30;\r
- UInt32 posReduced = (UInt32(1) << footerBits) - 1;\r
- _rangeEncoder.EncodeDirectBits(posReduced >> kNumAlignBits, footerBits - kNumAlignBits);\r
- _posAlignEncoder.ReverseEncode(&_rangeEncoder, posReduced & kAlignMask);\r
-}\r
-\r
-HRESULT CEncoder::CodeReal(ISequentialInStream *inStream,\r
- ISequentialOutStream *outStream, \r
- const UInt64 *inSize, const UInt64 *outSize,\r
- ICompressProgressInfo *progress)\r
-{\r
- _needReleaseMFStream = false;\r
- CCoderReleaser coderReleaser(this);\r
- RINOK(SetStreams(inStream, outStream, inSize, outSize));\r
- while(true)\r
- {\r
- UInt64 processedInSize;\r
- UInt64 processedOutSize;\r
- Int32 finished;\r
- RINOK(CodeOneBlock(&processedInSize, &processedOutSize, &finished));\r
- if (finished != 0)\r
- return S_OK;\r
- if (progress != 0)\r
- {\r
- RINOK(progress->SetRatioInfo(&processedInSize, &processedOutSize));\r
- }\r
- }\r
-}\r
-\r
-HRESULT CEncoder::SetStreams(ISequentialInStream *inStream,\r
- ISequentialOutStream *outStream, \r
- const UInt64 *inSize, const UInt64 *outSize)\r
-{\r
- _inStream = inStream;\r
- _finished = false;\r
- RINOK(Create());\r
- RINOK(SetOutStream(outStream));\r
- RINOK(Init());\r
- \r
- // CCoderReleaser releaser(this);\r
-\r
- /*\r
- if (_matchFinder->GetNumAvailableBytes() == 0)\r
- return Flush();\r
- */\r
-\r
- if (!_fastMode)\r
- {\r
- FillDistancesPrices();\r
- FillAlignPrices();\r
- }\r
-\r
- _lenEncoder.SetTableSize(_numFastBytes + 1 - kMatchMinLen);\r
- _lenEncoder.UpdateTables(1 << _posStateBits);\r
- _repMatchLenEncoder.SetTableSize(_numFastBytes + 1 - kMatchMinLen);\r
- _repMatchLenEncoder.UpdateTables(1 << _posStateBits);\r
-\r
- nowPos64 = 0;\r
- return S_OK;\r
-}\r
-\r
-HRESULT CEncoder::CodeOneBlock(UInt64 *inSize, UInt64 *outSize, Int32 *finished)\r
-{\r
- if (_inStream != 0)\r
- {\r
- RINOK(_matchFinder->SetStream(_inStream));\r
- RINOK(_matchFinder->Init());\r
- _needReleaseMFStream = true;\r
- _inStream = 0;\r
- }\r
-\r
-\r
- *finished = 1;\r
- if (_finished)\r
- return S_OK;\r
- _finished = true;\r
-\r
- if (nowPos64 == 0)\r
- {\r
- if (_matchFinder->GetNumAvailableBytes() == 0)\r
- return Flush(UInt32(nowPos64));\r
- UInt32 len, numDistancePairs;\r
- RINOK(ReadMatchDistances(len, numDistancePairs));\r
- UInt32 posState = UInt32(nowPos64) & _posStateMask;\r
- _isMatch[_state.Index][posState].Encode(&_rangeEncoder, 0);\r
- _state.UpdateChar();\r
- Byte curByte = _matchFinder->GetIndexByte(0 - _additionalOffset);\r
- _literalEncoder.GetSubCoder(UInt32(nowPos64), _previousByte)->Encode(&_rangeEncoder, curByte);\r
- _previousByte = curByte;\r
- _additionalOffset--;\r
- nowPos64++;\r
- }\r
-\r
- UInt32 nowPos32 = (UInt32)nowPos64;\r
- UInt32 progressPosValuePrev = nowPos32;\r
-\r
- if (_matchFinder->GetNumAvailableBytes() == 0)\r
- return Flush(nowPos32);\r
-\r
- while(true)\r
- {\r
- #ifdef _NO_EXCEPTIONS\r
- if (_rangeEncoder.Stream.ErrorCode != S_OK)\r
- return _rangeEncoder.Stream.ErrorCode;\r
- #endif\r
- UInt32 pos, len;\r
- HRESULT result;\r
- if (_fastMode)\r
- result = GetOptimumFast(nowPos32, pos, len);\r
- else\r
- result = GetOptimum(nowPos32, pos, len);\r
- RINOK(result);\r
-\r
- UInt32 posState = nowPos32 & _posStateMask;\r
- if(len == 1 && pos == 0xFFFFFFFF)\r
- {\r
- _isMatch[_state.Index][posState].Encode(&_rangeEncoder, 0);\r
- Byte curByte = _matchFinder->GetIndexByte(0 - _additionalOffset);\r
- CLiteralEncoder2 *subCoder = _literalEncoder.GetSubCoder(nowPos32, _previousByte);\r
- if(_state.IsCharState())\r
- subCoder->Encode(&_rangeEncoder, curByte);\r
- else\r
- {\r
- Byte matchByte = _matchFinder->GetIndexByte(0 - _repDistances[0] - 1 - _additionalOffset);\r
- subCoder->EncodeMatched(&_rangeEncoder, matchByte, curByte);\r
- }\r
- _state.UpdateChar();\r
- _previousByte = curByte;\r
- }\r
- else\r
- {\r
- _isMatch[_state.Index][posState].Encode(&_rangeEncoder, 1);\r
- if(pos < kNumRepDistances)\r
- {\r
- _isRep[_state.Index].Encode(&_rangeEncoder, 1);\r
- if(pos == 0)\r
- {\r
- _isRepG0[_state.Index].Encode(&_rangeEncoder, 0);\r
- _isRep0Long[_state.Index][posState].Encode(&_rangeEncoder, ((len == 1) ? 0 : 1));\r
- }\r
- else\r
- {\r
- UInt32 distance = _repDistances[pos];\r
- _isRepG0[_state.Index].Encode(&_rangeEncoder, 1);\r
- if (pos == 1)\r
- _isRepG1[_state.Index].Encode(&_rangeEncoder, 0);\r
- else\r
- {\r
- _isRepG1[_state.Index].Encode(&_rangeEncoder, 1);\r
- _isRepG2[_state.Index].Encode(&_rangeEncoder, pos - 2);\r
- if (pos == 3)\r
- _repDistances[3] = _repDistances[2];\r
- _repDistances[2] = _repDistances[1];\r
- }\r
- _repDistances[1] = _repDistances[0];\r
- _repDistances[0] = distance;\r
- }\r
- if (len == 1)\r
- _state.UpdateShortRep();\r
- else\r
- {\r
- _repMatchLenEncoder.Encode(&_rangeEncoder, len - kMatchMinLen, posState, !_fastMode);\r
- _state.UpdateRep();\r
- }\r
- }\r
- else\r
- {\r
- _isRep[_state.Index].Encode(&_rangeEncoder, 0);\r
- _state.UpdateMatch();\r
- _lenEncoder.Encode(&_rangeEncoder, len - kMatchMinLen, posState, !_fastMode);\r
- pos -= kNumRepDistances;\r
- UInt32 posSlot = GetPosSlot(pos);\r
- _posSlotEncoder[GetLenToPosState(len)].Encode(&_rangeEncoder, posSlot);\r
- \r
- if (posSlot >= kStartPosModelIndex)\r
- {\r
- UInt32 footerBits = ((posSlot >> 1) - 1);\r
- UInt32 base = ((2 | (posSlot & 1)) << footerBits);\r
- UInt32 posReduced = pos - base;\r
-\r
- if (posSlot < kEndPosModelIndex)\r
- NRangeCoder::ReverseBitTreeEncode(_posEncoders + base - posSlot - 1, \r
- &_rangeEncoder, footerBits, posReduced);\r
- else\r
- {\r
- _rangeEncoder.EncodeDirectBits(posReduced >> kNumAlignBits, footerBits - kNumAlignBits);\r
- _posAlignEncoder.ReverseEncode(&_rangeEncoder, posReduced & kAlignMask);\r
- _alignPriceCount++;\r
- }\r
- }\r
- _repDistances[3] = _repDistances[2];\r
- _repDistances[2] = _repDistances[1];\r
- _repDistances[1] = _repDistances[0];\r
- _repDistances[0] = pos;\r
- _matchPriceCount++;\r
- }\r
- _previousByte = _matchFinder->GetIndexByte(len - 1 - _additionalOffset);\r
- }\r
- _additionalOffset -= len;\r
- nowPos32 += len;\r
- if (_additionalOffset == 0)\r
- {\r
- if (!_fastMode)\r
- {\r
- if (_matchPriceCount >= (1 << 7))\r
- FillDistancesPrices();\r
- if (_alignPriceCount >= kAlignTableSize)\r
- FillAlignPrices();\r
- }\r
- if (_matchFinder->GetNumAvailableBytes() == 0)\r
- return Flush(nowPos32);\r
- if (nowPos32 - progressPosValuePrev >= (1 << 14))\r
- {\r
- nowPos64 += nowPos32 - progressPosValuePrev;\r
- *inSize = nowPos64;\r
- *outSize = _rangeEncoder.GetProcessedSize();\r
- _finished = false;\r
- *finished = 0;\r
- return S_OK;\r
- }\r
- }\r
- }\r
-}\r
-\r
-STDMETHODIMP CEncoder::Code(ISequentialInStream *inStream,\r
- ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,\r
- ICompressProgressInfo *progress)\r
-{\r
- #ifndef _NO_EXCEPTIONS\r
- try \r
- { \r
- #endif\r
- return CodeReal(inStream, outStream, inSize, outSize, progress); \r
- #ifndef _NO_EXCEPTIONS\r
- }\r
- catch(const COutBufferException &e) { return e.ErrorCode; }\r
- catch(...) { return E_FAIL; }\r
- #endif\r
-}\r
- \r
-void CEncoder::FillDistancesPrices()\r
-{\r
- UInt32 tempPrices[kNumFullDistances];\r
- for (UInt32 i = kStartPosModelIndex; i < kNumFullDistances; i++)\r
- { \r
- UInt32 posSlot = GetPosSlot(i);\r
- UInt32 footerBits = ((posSlot >> 1) - 1);\r
- UInt32 base = ((2 | (posSlot & 1)) << footerBits);\r
- tempPrices[i] = NRangeCoder::ReverseBitTreeGetPrice(_posEncoders + \r
- base - posSlot - 1, footerBits, i - base);\r
- }\r
-\r
- for (UInt32 lenToPosState = 0; lenToPosState < kNumLenToPosStates; lenToPosState++)\r
- {\r
- UInt32 posSlot;\r
- NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumPosSlotBits> &encoder = _posSlotEncoder[lenToPosState];\r
- UInt32 *posSlotPrices = _posSlotPrices[lenToPosState];\r
- for (posSlot = 0; posSlot < _distTableSize; posSlot++)\r
- posSlotPrices[posSlot] = encoder.GetPrice(posSlot);\r
- for (posSlot = kEndPosModelIndex; posSlot < _distTableSize; posSlot++)\r
- posSlotPrices[posSlot] += ((((posSlot >> 1) - 1) - kNumAlignBits) << NRangeCoder::kNumBitPriceShiftBits);\r
-\r
- UInt32 *distancesPrices = _distancesPrices[lenToPosState];\r
- UInt32 i;\r
- for (i = 0; i < kStartPosModelIndex; i++)\r
- distancesPrices[i] = posSlotPrices[i];\r
- for (; i < kNumFullDistances; i++)\r
- distancesPrices[i] = posSlotPrices[GetPosSlot(i)] + tempPrices[i];\r
- }\r
- _matchPriceCount = 0;\r
-}\r
-\r
-void CEncoder::FillAlignPrices()\r
-{\r
- for (UInt32 i = 0; i < kAlignTableSize; i++)\r
- _alignPrices[i] = _posAlignEncoder.ReverseGetPrice(i);\r
- _alignPriceCount = 0;\r
-}\r
-\r
-}}\r
+++ /dev/null
-// LZMA/Encoder.h\r
-\r
-#ifndef __LZMA_ENCODER_H\r
-#define __LZMA_ENCODER_H\r
-\r
-#include "../../../Common/MyCom.h"\r
-#include "../../../Common/Alloc.h"\r
-#include "../../ICoder.h"\r
-#include "../LZ/IMatchFinder.h"\r
-#include "../RangeCoder/RangeCoderBitTree.h"\r
-\r
-#include "LZMA.h"\r
-\r
-namespace NCompress {\r
-namespace NLZMA {\r
-\r
-typedef NRangeCoder::CBitEncoder<kNumMoveBits> CMyBitEncoder;\r
-\r
-class CBaseState\r
-{\r
-protected:\r
- CState _state;\r
- Byte _previousByte;\r
- UInt32 _repDistances[kNumRepDistances];\r
- void Init()\r
- {\r
- _state.Init();\r
- _previousByte = 0;\r
- for(UInt32 i = 0 ; i < kNumRepDistances; i++)\r
- _repDistances[i] = 0;\r
- }\r
-};\r
-\r
-struct COptimal\r
-{\r
- CState State;\r
-\r
- bool Prev1IsChar;\r
- bool Prev2;\r
-\r
- UInt32 PosPrev2;\r
- UInt32 BackPrev2; \r
-\r
- UInt32 Price; \r
- UInt32 PosPrev; // posNext;\r
- UInt32 BackPrev; \r
- UInt32 Backs[kNumRepDistances];\r
- void MakeAsChar() { BackPrev = UInt32(-1); Prev1IsChar = false; }\r
- void MakeAsShortRep() { BackPrev = 0; ; Prev1IsChar = false; }\r
- bool IsShortRep() { return (BackPrev == 0); }\r
-};\r
-\r
-\r
-extern Byte g_FastPos[1 << 11];\r
-inline UInt32 GetPosSlot(UInt32 pos)\r
-{\r
- if (pos < (1 << 11))\r
- return g_FastPos[pos];\r
- if (pos < (1 << 21))\r
- return g_FastPos[pos >> 10] + 20;\r
- return g_FastPos[pos >> 20] + 40;\r
-}\r
-\r
-inline UInt32 GetPosSlot2(UInt32 pos)\r
-{\r
- if (pos < (1 << 17))\r
- return g_FastPos[pos >> 6] + 12;\r
- if (pos < (1 << 27))\r
- return g_FastPos[pos >> 16] + 32;\r
- return g_FastPos[pos >> 26] + 52;\r
-}\r
-\r
-const UInt32 kIfinityPrice = 0xFFFFFFF;\r
-\r
-const UInt32 kNumOpts = 1 << 12;\r
-\r
-\r
-class CLiteralEncoder2\r
-{\r
- CMyBitEncoder _encoders[0x300];\r
-public:\r
- void Init()\r
- {\r
- for (int i = 0; i < 0x300; i++)\r
- _encoders[i].Init();\r
- }\r
- void Encode(NRangeCoder::CEncoder *rangeEncoder, Byte symbol);\r
- void EncodeMatched(NRangeCoder::CEncoder *rangeEncoder, Byte matchByte, Byte symbol);\r
- UInt32 GetPrice(bool matchMode, Byte matchByte, Byte symbol) const;\r
-};\r
-\r
-class CLiteralEncoder\r
-{\r
- CLiteralEncoder2 *_coders;\r
- int _numPrevBits;\r
- int _numPosBits;\r
- UInt32 _posMask;\r
-public:\r
- CLiteralEncoder(): _coders(0) {}\r
- ~CLiteralEncoder() { Free(); }\r
- void Free()\r
- { \r
- MyFree(_coders);\r
- _coders = 0;\r
- }\r
- bool Create(int numPosBits, int numPrevBits)\r
- {\r
- if (_coders == 0 || (numPosBits + numPrevBits) != (_numPrevBits + _numPosBits))\r
- {\r
- Free();\r
- UInt32 numStates = 1 << (numPosBits + numPrevBits);\r
- _coders = (CLiteralEncoder2 *)MyAlloc(numStates * sizeof(CLiteralEncoder2));\r
- }\r
- _numPosBits = numPosBits;\r
- _posMask = (1 << numPosBits) - 1;\r
- _numPrevBits = numPrevBits;\r
- return (_coders != 0);\r
- }\r
- void Init()\r
- {\r
- UInt32 numStates = 1 << (_numPrevBits + _numPosBits);\r
- for (UInt32 i = 0; i < numStates; i++)\r
- _coders[i].Init();\r
- }\r
- CLiteralEncoder2 *GetSubCoder(UInt32 pos, Byte prevByte)\r
- { return &_coders[((pos & _posMask) << _numPrevBits) + (prevByte >> (8 - _numPrevBits))]; }\r
-};\r
-\r
-namespace NLength {\r
-\r
-class CEncoder\r
-{\r
- CMyBitEncoder _choice;\r
- CMyBitEncoder _choice2;\r
- NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumLowBits> _lowCoder[kNumPosStatesEncodingMax];\r
- NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumMidBits> _midCoder[kNumPosStatesEncodingMax];\r
- NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumHighBits> _highCoder;\r
-public:\r
- void Init(UInt32 numPosStates);\r
- void Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 symbol, UInt32 posState);\r
- void SetPrices(UInt32 posState, UInt32 numSymbols, UInt32 *prices) const;\r
-};\r
-\r
-const UInt32 kNumSpecSymbols = kNumLowSymbols + kNumMidSymbols;\r
-\r
-class CPriceTableEncoder: public CEncoder\r
-{\r
- UInt32 _prices[kNumPosStatesEncodingMax][kNumSymbolsTotal];\r
- UInt32 _tableSize;\r
- UInt32 _counters[kNumPosStatesEncodingMax];\r
-public:\r
- void SetTableSize(UInt32 tableSize) { _tableSize = tableSize; }\r
- UInt32 GetPrice(UInt32 symbol, UInt32 posState) const { return _prices[posState][symbol]; }\r
- void UpdateTable(UInt32 posState)\r
- {\r
- SetPrices(posState, _tableSize, _prices[posState]);\r
- _counters[posState] = _tableSize;\r
- }\r
- void UpdateTables(UInt32 numPosStates)\r
- {\r
- for (UInt32 posState = 0; posState < numPosStates; posState++)\r
- UpdateTable(posState);\r
- }\r
- void Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 symbol, UInt32 posState, bool updatePrice)\r
- {\r
- CEncoder::Encode(rangeEncoder, symbol, posState);\r
- if (updatePrice)\r
- if (--_counters[posState] == 0)\r
- UpdateTable(posState);\r
- }\r
-};\r
-\r
-}\r
-\r
-class CEncoder : \r
- public ICompressCoder,\r
- public ICompressSetOutStream,\r
- public ICompressSetCoderProperties,\r
- public ICompressWriteCoderProperties,\r
- public CBaseState,\r
- public CMyUnknownImp\r
-{\r
- COptimal _optimum[kNumOpts];\r
- CMyComPtr<IMatchFinder> _matchFinder; // test it\r
- NRangeCoder::CEncoder _rangeEncoder;\r
-\r
- CMyBitEncoder _isMatch[kNumStates][NLength::kNumPosStatesEncodingMax];\r
- CMyBitEncoder _isRep[kNumStates];\r
- CMyBitEncoder _isRepG0[kNumStates];\r
- CMyBitEncoder _isRepG1[kNumStates];\r
- CMyBitEncoder _isRepG2[kNumStates];\r
- CMyBitEncoder _isRep0Long[kNumStates][NLength::kNumPosStatesEncodingMax];\r
-\r
- NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumPosSlotBits> _posSlotEncoder[kNumLenToPosStates];\r
-\r
- CMyBitEncoder _posEncoders[kNumFullDistances - kEndPosModelIndex];\r
- NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumAlignBits> _posAlignEncoder;\r
- \r
- NLength::CPriceTableEncoder _lenEncoder;\r
- NLength::CPriceTableEncoder _repMatchLenEncoder;\r
-\r
- CLiteralEncoder _literalEncoder;\r
-\r
- UInt32 _matchDistances[kMatchMaxLen * 2 + 2 + 1];\r
-\r
- bool _fastMode;\r
- // bool _maxMode;\r
- UInt32 _numFastBytes;\r
- UInt32 _longestMatchLength; \r
- UInt32 _numDistancePairs;\r
-\r
- UInt32 _additionalOffset;\r
-\r
- UInt32 _optimumEndIndex;\r
- UInt32 _optimumCurrentIndex;\r
-\r
- bool _longestMatchWasFound;\r
-\r
- UInt32 _posSlotPrices[kNumLenToPosStates][kDistTableSizeMax];\r
- \r
- UInt32 _distancesPrices[kNumLenToPosStates][kNumFullDistances];\r
-\r
- UInt32 _alignPrices[kAlignTableSize];\r
- UInt32 _alignPriceCount;\r
-\r
- UInt32 _distTableSize;\r
-\r
- UInt32 _posStateBits;\r
- UInt32 _posStateMask;\r
- UInt32 _numLiteralPosStateBits;\r
- UInt32 _numLiteralContextBits;\r
-\r
- UInt32 _dictionarySize;\r
-\r
- UInt32 _dictionarySizePrev;\r
- UInt32 _numFastBytesPrev;\r
-\r
- UInt32 _matchPriceCount;\r
- UInt64 nowPos64;\r
- bool _finished;\r
- ISequentialInStream *_inStream;\r
-\r
- UInt32 _matchFinderCycles;\r
- int _matchFinderIndex;\r
- #ifdef COMPRESS_MF_MT\r
- bool _multiThread;\r
- #endif\r
-\r
- bool _writeEndMark;\r
-\r
- bool _needReleaseMFStream;\r
-\r
- IMatchFinderSetNumPasses *setMfPasses;\r
-\r
- void ReleaseMatchFinder()\r
- {\r
- setMfPasses = 0;\r
- _matchFinder.Release();\r
- }\r
- \r
- HRESULT ReadMatchDistances(UInt32 &len, UInt32 &numDistancePairs);\r
-\r
- HRESULT MovePos(UInt32 num);\r
- UInt32 GetRepLen1Price(CState state, UInt32 posState) const\r
- {\r
- return _isRepG0[state.Index].GetPrice0() +\r
- _isRep0Long[state.Index][posState].GetPrice0();\r
- }\r
- \r
- UInt32 GetPureRepPrice(UInt32 repIndex, CState state, UInt32 posState) const\r
- {\r
- UInt32 price;\r
- if(repIndex == 0)\r
- {\r
- price = _isRepG0[state.Index].GetPrice0();\r
- price += _isRep0Long[state.Index][posState].GetPrice1();\r
- }\r
- else\r
- {\r
- price = _isRepG0[state.Index].GetPrice1();\r
- if (repIndex == 1)\r
- price += _isRepG1[state.Index].GetPrice0();\r
- else\r
- {\r
- price += _isRepG1[state.Index].GetPrice1();\r
- price += _isRepG2[state.Index].GetPrice(repIndex - 2);\r
- }\r
- }\r
- return price;\r
- }\r
- UInt32 GetRepPrice(UInt32 repIndex, UInt32 len, CState state, UInt32 posState) const\r
- {\r
- return _repMatchLenEncoder.GetPrice(len - kMatchMinLen, posState) +\r
- GetPureRepPrice(repIndex, state, posState);\r
- }\r
- /*\r
- UInt32 GetPosLen2Price(UInt32 pos, UInt32 posState) const\r
- {\r
- if (pos >= kNumFullDistances)\r
- return kIfinityPrice;\r
- return _distancesPrices[0][pos] + _lenEncoder.GetPrice(0, posState);\r
- }\r
- UInt32 GetPosLen3Price(UInt32 pos, UInt32 len, UInt32 posState) const\r
- {\r
- UInt32 price;\r
- UInt32 lenToPosState = GetLenToPosState(len);\r
- if (pos < kNumFullDistances)\r
- price = _distancesPrices[lenToPosState][pos];\r
- else\r
- price = _posSlotPrices[lenToPosState][GetPosSlot2(pos)] + \r
- _alignPrices[pos & kAlignMask];\r
- return price + _lenEncoder.GetPrice(len - kMatchMinLen, posState);\r
- }\r
- */\r
- UInt32 GetPosLenPrice(UInt32 pos, UInt32 len, UInt32 posState) const\r
- {\r
- UInt32 price;\r
- UInt32 lenToPosState = GetLenToPosState(len);\r
- if (pos < kNumFullDistances)\r
- price = _distancesPrices[lenToPosState][pos];\r
- else\r
- price = _posSlotPrices[lenToPosState][GetPosSlot2(pos)] + \r
- _alignPrices[pos & kAlignMask];\r
- return price + _lenEncoder.GetPrice(len - kMatchMinLen, posState);\r
- }\r
-\r
- UInt32 Backward(UInt32 &backRes, UInt32 cur);\r
- HRESULT GetOptimum(UInt32 position, UInt32 &backRes, UInt32 &lenRes);\r
- HRESULT GetOptimumFast(UInt32 position, UInt32 &backRes, UInt32 &lenRes);\r
-\r
- void FillDistancesPrices();\r
- void FillAlignPrices();\r
- \r
- void ReleaseMFStream()\r
- {\r
- if (_matchFinder && _needReleaseMFStream)\r
- {\r
- _matchFinder->ReleaseStream();\r
- _needReleaseMFStream = false;\r
- }\r
- }\r
-\r
- void ReleaseStreams()\r
- {\r
- ReleaseMFStream();\r
- ReleaseOutStream();\r
- }\r
-\r
- HRESULT Flush(UInt32 nowPos);\r
- class CCoderReleaser\r
- {\r
- CEncoder *_coder;\r
- public:\r
- CCoderReleaser(CEncoder *coder): _coder(coder) {}\r
- ~CCoderReleaser()\r
- {\r
- _coder->ReleaseStreams();\r
- }\r
- };\r
- friend class CCoderReleaser;\r
-\r
- void WriteEndMarker(UInt32 posState);\r
-\r
-public:\r
- CEncoder();\r
- void SetWriteEndMarkerMode(bool writeEndMarker)\r
- { _writeEndMark= writeEndMarker; }\r
-\r
- HRESULT Create();\r
-\r
- MY_UNKNOWN_IMP3(\r
- ICompressSetOutStream,\r
- ICompressSetCoderProperties,\r
- ICompressWriteCoderProperties\r
- )\r
- \r
- HRESULT Init();\r
- \r
- // ICompressCoder interface\r
- HRESULT SetStreams(ISequentialInStream *inStream,\r
- ISequentialOutStream *outStream,\r
- const UInt64 *inSize, const UInt64 *outSize);\r
- HRESULT CodeOneBlock(UInt64 *inSize, UInt64 *outSize, Int32 *finished);\r
-\r
- HRESULT CodeReal(ISequentialInStream *inStream,\r
- ISequentialOutStream *outStream, \r
- const UInt64 *inSize, const UInt64 *outSize,\r
- ICompressProgressInfo *progress);\r
-\r
- // ICompressCoder interface\r
- STDMETHOD(Code)(ISequentialInStream *inStream,\r
- ISequentialOutStream *outStream, \r
- const UInt64 *inSize, const UInt64 *outSize,\r
- ICompressProgressInfo *progress);\r
-\r
- // ICompressSetCoderProperties2\r
- STDMETHOD(SetCoderProperties)(const PROPID *propIDs, \r
- const PROPVARIANT *properties, UInt32 numProperties);\r
- \r
- // ICompressWriteCoderProperties\r
- STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);\r
-\r
- STDMETHOD(SetOutStream)(ISequentialOutStream *outStream);\r
- STDMETHOD(ReleaseOutStream)();\r
-\r
- virtual ~CEncoder() {}\r
-};\r
-\r
-}}\r
-\r
-#endif\r
+++ /dev/null
-// StdAfx.h\r
-\r
-#ifndef __STDAFX_H\r
-#define __STDAFX_H\r
-\r
-#include "../../../Common/MyWindows.h"\r
-\r
-#endif\r
+++ /dev/null
-// Compress/RangeCoder/RangeCoder.h\r
-\r
-#ifndef __COMPRESS_RANGECODER_H\r
-#define __COMPRESS_RANGECODER_H\r
-\r
-#include "../../Common/InBuffer.h"\r
-#include "../../Common/OutBuffer.h"\r
-\r
-namespace NCompress {\r
-namespace NRangeCoder {\r
-\r
-const int kNumTopBits = 24;\r
-const UInt32 kTopValue = (1 << kNumTopBits);\r
-\r
-class CEncoder\r
-{\r
- UInt32 _cacheSize;\r
- Byte _cache;\r
-public:\r
- UInt64 Low;\r
- UInt32 Range;\r
- COutBuffer Stream;\r
- bool Create(UInt32 bufferSize) { return Stream.Create(bufferSize); }\r
-\r
- void SetStream(ISequentialOutStream *stream) { Stream.SetStream(stream); }\r
- void Init()\r
- {\r
- Stream.Init();\r
- Low = 0;\r
- Range = 0xFFFFFFFF;\r
- _cacheSize = 1;\r
- _cache = 0;\r
- }\r
-\r
- void FlushData()\r
- {\r
- // Low += 1; \r
- for(int i = 0; i < 5; i++)\r
- ShiftLow();\r
- }\r
-\r
- HRESULT FlushStream() { return Stream.Flush(); }\r
-\r
- void ReleaseStream() { Stream.ReleaseStream(); }\r
-\r
- void Encode(UInt32 start, UInt32 size, UInt32 total)\r
- {\r
- Low += start * (Range /= total);\r
- Range *= size;\r
- while (Range < kTopValue)\r
- {\r
- Range <<= 8;\r
- ShiftLow();\r
- }\r
- }\r
-\r
- void ShiftLow()\r
- {\r
- if ((UInt32)Low < (UInt32)0xFF000000 || (int)(Low >> 32) != 0) \r
- {\r
- Byte temp = _cache;\r
- do\r
- {\r
- Stream.WriteByte((Byte)(temp + (Byte)(Low >> 32)));\r
- temp = 0xFF;\r
- }\r
- while(--_cacheSize != 0);\r
- _cache = (Byte)((UInt32)Low >> 24); \r
- } \r
- _cacheSize++; \r
- Low = (UInt32)Low << 8; \r
- }\r
- \r
- void EncodeDirectBits(UInt32 value, int numTotalBits)\r
- {\r
- for (int i = numTotalBits - 1; i >= 0; i--)\r
- {\r
- Range >>= 1;\r
- if (((value >> i) & 1) == 1)\r
- Low += Range;\r
- if (Range < kTopValue)\r
- {\r
- Range <<= 8;\r
- ShiftLow();\r
- }\r
- }\r
- }\r
-\r
- void EncodeBit(UInt32 size0, UInt32 numTotalBits, UInt32 symbol)\r
- {\r
- UInt32 newBound = (Range >> numTotalBits) * size0;\r
- if (symbol == 0)\r
- Range = newBound;\r
- else\r
- {\r
- Low += newBound;\r
- Range -= newBound;\r
- }\r
- while (Range < kTopValue)\r
- {\r
- Range <<= 8;\r
- ShiftLow();\r
- }\r
- }\r
-\r
- UInt64 GetProcessedSize() { return Stream.GetProcessedSize() + _cacheSize + 4; }\r
-};\r
-\r
-class CDecoder\r
-{\r
-public:\r
- CInBuffer Stream;\r
- UInt32 Range;\r
- UInt32 Code;\r
- bool Create(UInt32 bufferSize) { return Stream.Create(bufferSize); }\r
-\r
- void Normalize()\r
- {\r
- while (Range < kTopValue)\r
- {\r
- Code = (Code << 8) | Stream.ReadByte();\r
- Range <<= 8;\r
- }\r
- }\r
- \r
- void SetStream(ISequentialInStream *stream) { Stream.SetStream(stream); }\r
- void Init()\r
- {\r
- Stream.Init();\r
- Code = 0;\r
- Range = 0xFFFFFFFF;\r
- for(int i = 0; i < 5; i++)\r
- Code = (Code << 8) | Stream.ReadByte();\r
- }\r
-\r
- void ReleaseStream() { Stream.ReleaseStream(); }\r
-\r
- UInt32 GetThreshold(UInt32 total)\r
- {\r
- return (Code) / ( Range /= total);\r
- }\r
-\r
- void Decode(UInt32 start, UInt32 size)\r
- {\r
- Code -= start * Range;\r
- Range *= size;\r
- Normalize();\r
- }\r
-\r
- UInt32 DecodeDirectBits(int numTotalBits)\r
- {\r
- UInt32 range = Range;\r
- UInt32 code = Code; \r
- UInt32 result = 0;\r
- for (int i = numTotalBits; i != 0; i--)\r
- {\r
- range >>= 1;\r
- /*\r
- result <<= 1;\r
- if (code >= range)\r
- {\r
- code -= range;\r
- result |= 1;\r
- }\r
- */\r
- UInt32 t = (code - range) >> 31;\r
- code -= range & (t - 1);\r
- result = (result << 1) | (1 - t);\r
-\r
- if (range < kTopValue)\r
- {\r
- code = (code << 8) | Stream.ReadByte();\r
- range <<= 8; \r
- }\r
- }\r
- Range = range;\r
- Code = code;\r
- return result;\r
- }\r
-\r
- UInt32 DecodeBit(UInt32 size0, UInt32 numTotalBits)\r
- {\r
- UInt32 newBound = (Range >> numTotalBits) * size0;\r
- UInt32 symbol;\r
- if (Code < newBound)\r
- {\r
- symbol = 0;\r
- Range = newBound;\r
- }\r
- else\r
- {\r
- symbol = 1;\r
- Code -= newBound;\r
- Range -= newBound;\r
- }\r
- Normalize();\r
- return symbol;\r
- }\r
-\r
- UInt64 GetProcessedSize() {return Stream.GetProcessedSize(); }\r
-};\r
-\r
-}}\r
-\r
-#endif\r
+++ /dev/null
-// Compress/RangeCoder/RangeCoderBit.cpp\r
-\r
-#include "StdAfx.h"\r
-\r
-#include "RangeCoderBit.h"\r
-\r
-namespace NCompress {\r
-namespace NRangeCoder {\r
-\r
-UInt32 CPriceTables::ProbPrices[kBitModelTotal >> kNumMoveReducingBits];\r
-static CPriceTables g_PriceTables;\r
-\r
-CPriceTables::CPriceTables() { Init(); }\r
-\r
-void CPriceTables::Init()\r
-{\r
- const int kNumBits = (kNumBitModelTotalBits - kNumMoveReducingBits);\r
- for(int i = kNumBits - 1; i >= 0; i--)\r
- {\r
- UInt32 start = 1 << (kNumBits - i - 1);\r
- UInt32 end = 1 << (kNumBits - i);\r
- for (UInt32 j = start; j < end; j++)\r
- ProbPrices[j] = (i << kNumBitPriceShiftBits) + \r
- (((end - j) << kNumBitPriceShiftBits) >> (kNumBits - i - 1));\r
- }\r
-\r
- /*\r
- // simplest: bad solution\r
- for(UInt32 i = 1; i < (kBitModelTotal >> kNumMoveReducingBits) - 1; i++)\r
- ProbPrices[i] = kBitPrice;\r
- */\r
- \r
- /*\r
- const double kDummyMultMid = (1.0 / kBitPrice) / 2;\r
- const double kDummyMultMid = 0;\r
- // float solution\r
- double ln2 = log(double(2));\r
- double lnAll = log(double(kBitModelTotal >> kNumMoveReducingBits));\r
- for(UInt32 i = 1; i < (kBitModelTotal >> kNumMoveReducingBits) - 1; i++)\r
- ProbPrices[i] = UInt32((fabs(lnAll - log(double(i))) / ln2 + kDummyMultMid) * kBitPrice);\r
- */\r
- \r
- /*\r
- // experimental, slow, solution:\r
- for(UInt32 i = 1; i < (kBitModelTotal >> kNumMoveReducingBits) - 1; i++)\r
- {\r
- const int kCyclesBits = 5;\r
- const UInt32 kCycles = (1 << kCyclesBits);\r
-\r
- UInt32 range = UInt32(-1);\r
- UInt32 bitCount = 0;\r
- for (UInt32 j = 0; j < kCycles; j++)\r
- {\r
- range >>= (kNumBitModelTotalBits - kNumMoveReducingBits);\r
- range *= i;\r
- while(range < (1 << 31))\r
- {\r
- range <<= 1;\r
- bitCount++;\r
- }\r
- }\r
- bitCount <<= kNumBitPriceShiftBits;\r
- range -= (1 << 31);\r
- for (int k = kNumBitPriceShiftBits - 1; k >= 0; k--)\r
- {\r
- range <<= 1;\r
- if (range > (1 << 31))\r
- {\r
- bitCount += (1 << k);\r
- range -= (1 << 31);\r
- }\r
- }\r
- ProbPrices[i] = (bitCount \r
- // + (1 << (kCyclesBits - 1))\r
- ) >> kCyclesBits;\r
- }\r
- */\r
-}\r
-\r
-}}\r
+++ /dev/null
-// Compress/RangeCoder/RangeCoderBit.h\r
-\r
-#ifndef __COMPRESS_RANGECODER_BIT_H\r
-#define __COMPRESS_RANGECODER_BIT_H\r
-\r
-#include "RangeCoder.h"\r
-\r
-namespace NCompress {\r
-namespace NRangeCoder {\r
-\r
-const int kNumBitModelTotalBits = 11;\r
-const UInt32 kBitModelTotal = (1 << kNumBitModelTotalBits);\r
-\r
-const int kNumMoveReducingBits = 2;\r
-\r
-const int kNumBitPriceShiftBits = 6;\r
-const UInt32 kBitPrice = 1 << kNumBitPriceShiftBits;\r
-\r
-class CPriceTables\r
-{\r
-public:\r
- static UInt32 ProbPrices[kBitModelTotal >> kNumMoveReducingBits];\r
- static void Init();\r
- CPriceTables();\r
-};\r
-\r
-template <int numMoveBits>\r
-class CBitModel\r
-{\r
-public:\r
- UInt32 Prob;\r
- void UpdateModel(UInt32 symbol)\r
- {\r
- /*\r
- Prob -= (Prob + ((symbol - 1) & ((1 << numMoveBits) - 1))) >> numMoveBits;\r
- Prob += (1 - symbol) << (kNumBitModelTotalBits - numMoveBits);\r
- */\r
- if (symbol == 0)\r
- Prob += (kBitModelTotal - Prob) >> numMoveBits;\r
- else\r
- Prob -= (Prob) >> numMoveBits;\r
- }\r
-public:\r
- void Init() { Prob = kBitModelTotal / 2; }\r
-};\r
-\r
-template <int numMoveBits>\r
-class CBitEncoder: public CBitModel<numMoveBits>\r
-{\r
-public:\r
- void Encode(CEncoder *encoder, UInt32 symbol)\r
- {\r
- /*\r
- encoder->EncodeBit(this->Prob, kNumBitModelTotalBits, symbol);\r
- this->UpdateModel(symbol);\r
- */\r
- UInt32 newBound = (encoder->Range >> kNumBitModelTotalBits) * this->Prob;\r
- if (symbol == 0)\r
- {\r
- encoder->Range = newBound;\r
- this->Prob += (kBitModelTotal - this->Prob) >> numMoveBits;\r
- }\r
- else\r
- {\r
- encoder->Low += newBound;\r
- encoder->Range -= newBound;\r
- this->Prob -= (this->Prob) >> numMoveBits;\r
- }\r
- if (encoder->Range < kTopValue)\r
- {\r
- encoder->Range <<= 8;\r
- encoder->ShiftLow();\r
- }\r
- }\r
- UInt32 GetPrice(UInt32 symbol) const\r
- {\r
- return CPriceTables::ProbPrices[\r
- (((this->Prob - symbol) ^ ((-(int)symbol))) & (kBitModelTotal - 1)) >> kNumMoveReducingBits];\r
- }\r
- UInt32 GetPrice0() const { return CPriceTables::ProbPrices[this->Prob >> kNumMoveReducingBits]; }\r
- UInt32 GetPrice1() const { return CPriceTables::ProbPrices[(kBitModelTotal - this->Prob) >> kNumMoveReducingBits]; }\r
-};\r
-\r
-\r
-template <int numMoveBits>\r
-class CBitDecoder: public CBitModel<numMoveBits>\r
-{\r
-public:\r
- UInt32 Decode(CDecoder *decoder)\r
- {\r
- UInt32 newBound = (decoder->Range >> kNumBitModelTotalBits) * this->Prob;\r
- if (decoder->Code < newBound)\r
- {\r
- decoder->Range = newBound;\r
- this->Prob += (kBitModelTotal - this->Prob) >> numMoveBits;\r
- if (decoder->Range < kTopValue)\r
- {\r
- decoder->Code = (decoder->Code << 8) | decoder->Stream.ReadByte();\r
- decoder->Range <<= 8;\r
- }\r
- return 0;\r
- }\r
- else\r
- {\r
- decoder->Range -= newBound;\r
- decoder->Code -= newBound;\r
- this->Prob -= (this->Prob) >> numMoveBits;\r
- if (decoder->Range < kTopValue)\r
- {\r
- decoder->Code = (decoder->Code << 8) | decoder->Stream.ReadByte();\r
- decoder->Range <<= 8;\r
- }\r
- return 1;\r
- }\r
- }\r
-};\r
-\r
-}}\r
-\r
-#endif\r
+++ /dev/null
-// Compress/RangeCoder/RangeCoderBitTree.h\r
-\r
-#ifndef __COMPRESS_RANGECODER_BIT_TREE_H\r
-#define __COMPRESS_RANGECODER_BIT_TREE_H\r
-\r
-#include "RangeCoderBit.h"\r
-#include "RangeCoderOpt.h"\r
-\r
-namespace NCompress {\r
-namespace NRangeCoder {\r
-\r
-template <int numMoveBits, int NumBitLevels>\r
-class CBitTreeEncoder\r
-{\r
- CBitEncoder<numMoveBits> Models[1 << NumBitLevels];\r
-public:\r
- void Init()\r
- {\r
- for(UInt32 i = 1; i < (1 << NumBitLevels); i++)\r
- Models[i].Init();\r
- }\r
- void Encode(CEncoder *rangeEncoder, UInt32 symbol)\r
- {\r
- UInt32 modelIndex = 1;\r
- for (int bitIndex = NumBitLevels; bitIndex != 0 ;)\r
- {\r
- bitIndex--;\r
- UInt32 bit = (symbol >> bitIndex) & 1;\r
- Models[modelIndex].Encode(rangeEncoder, bit);\r
- modelIndex = (modelIndex << 1) | bit;\r
- }\r
- };\r
- void ReverseEncode(CEncoder *rangeEncoder, UInt32 symbol)\r
- {\r
- UInt32 modelIndex = 1;\r
- for (int i = 0; i < NumBitLevels; i++)\r
- {\r
- UInt32 bit = symbol & 1;\r
- Models[modelIndex].Encode(rangeEncoder, bit);\r
- modelIndex = (modelIndex << 1) | bit;\r
- symbol >>= 1;\r
- }\r
- }\r
- UInt32 GetPrice(UInt32 symbol) const\r
- {\r
- symbol |= (1 << NumBitLevels);\r
- UInt32 price = 0;\r
- while (symbol != 1)\r
- {\r
- price += Models[symbol >> 1].GetPrice(symbol & 1);\r
- symbol >>= 1;\r
- }\r
- return price;\r
- }\r
- UInt32 ReverseGetPrice(UInt32 symbol) const\r
- {\r
- UInt32 price = 0;\r
- UInt32 modelIndex = 1;\r
- for (int i = NumBitLevels; i != 0; i--)\r
- {\r
- UInt32 bit = symbol & 1;\r
- symbol >>= 1;\r
- price += Models[modelIndex].GetPrice(bit);\r
- modelIndex = (modelIndex << 1) | bit;\r
- }\r
- return price;\r
- }\r
-};\r
-\r
-template <int numMoveBits, int NumBitLevels>\r
-class CBitTreeDecoder\r
-{\r
- CBitDecoder<numMoveBits> Models[1 << NumBitLevels];\r
-public:\r
- void Init()\r
- {\r
- for(UInt32 i = 1; i < (1 << NumBitLevels); i++)\r
- Models[i].Init();\r
- }\r
- UInt32 Decode(CDecoder *rangeDecoder)\r
- {\r
- UInt32 modelIndex = 1;\r
- RC_INIT_VAR\r
- for(int bitIndex = NumBitLevels; bitIndex != 0; bitIndex--)\r
- {\r
- // modelIndex = (modelIndex << 1) + Models[modelIndex].Decode(rangeDecoder);\r
- RC_GETBIT(numMoveBits, Models[modelIndex].Prob, modelIndex)\r
- }\r
- RC_FLUSH_VAR\r
- return modelIndex - (1 << NumBitLevels);\r
- };\r
- UInt32 ReverseDecode(CDecoder *rangeDecoder)\r
- {\r
- UInt32 modelIndex = 1;\r
- UInt32 symbol = 0;\r
- RC_INIT_VAR\r
- for(int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)\r
- {\r
- // UInt32 bit = Models[modelIndex].Decode(rangeDecoder);\r
- // modelIndex <<= 1;\r
- // modelIndex += bit;\r
- // symbol |= (bit << bitIndex);\r
- RC_GETBIT2(numMoveBits, Models[modelIndex].Prob, modelIndex, ; , symbol |= (1 << bitIndex))\r
- }\r
- RC_FLUSH_VAR\r
- return symbol;\r
- }\r
-};\r
-\r
-template <int numMoveBits>\r
-void ReverseBitTreeEncode(CBitEncoder<numMoveBits> *Models, \r
- CEncoder *rangeEncoder, int NumBitLevels, UInt32 symbol)\r
-{\r
- UInt32 modelIndex = 1;\r
- for (int i = 0; i < NumBitLevels; i++)\r
- {\r
- UInt32 bit = symbol & 1;\r
- Models[modelIndex].Encode(rangeEncoder, bit);\r
- modelIndex = (modelIndex << 1) | bit;\r
- symbol >>= 1;\r
- }\r
-}\r
-\r
-template <int numMoveBits>\r
-UInt32 ReverseBitTreeGetPrice(CBitEncoder<numMoveBits> *Models, \r
- UInt32 NumBitLevels, UInt32 symbol)\r
-{\r
- UInt32 price = 0;\r
- UInt32 modelIndex = 1;\r
- for (int i = NumBitLevels; i != 0; i--)\r
- {\r
- UInt32 bit = symbol & 1;\r
- symbol >>= 1;\r
- price += Models[modelIndex].GetPrice(bit);\r
- modelIndex = (modelIndex << 1) | bit;\r
- }\r
- return price;\r
-}\r
-\r
-template <int numMoveBits>\r
-UInt32 ReverseBitTreeDecode(CBitDecoder<numMoveBits> *Models, \r
- CDecoder *rangeDecoder, int NumBitLevels)\r
-{\r
- UInt32 modelIndex = 1;\r
- UInt32 symbol = 0;\r
- RC_INIT_VAR\r
- for(int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)\r
- {\r
- // UInt32 bit = Models[modelIndex].Decode(rangeDecoder);\r
- // modelIndex <<= 1;\r
- // modelIndex += bit;\r
- // symbol |= (bit << bitIndex);\r
- RC_GETBIT2(numMoveBits, Models[modelIndex].Prob, modelIndex, ; , symbol |= (1 << bitIndex))\r
- }\r
- RC_FLUSH_VAR\r
- return symbol;\r
-}\r
-\r
-}}\r
-\r
-#endif\r
+++ /dev/null
-// Compress/RangeCoder/RangeCoderOpt.h\r
-\r
-#ifndef __COMPRESS_RANGECODER_OPT_H\r
-#define __COMPRESS_RANGECODER_OPT_H\r
-\r
-#define RC_INIT_VAR \\r
- UInt32 range = rangeDecoder->Range; \\r
- UInt32 code = rangeDecoder->Code; \r
-\r
-#define RC_FLUSH_VAR \\r
- rangeDecoder->Range = range; \\r
- rangeDecoder->Code = code;\r
-\r
-#define RC_NORMALIZE \\r
- if (range < NCompress::NRangeCoder::kTopValue) \\r
- { code = (code << 8) | rangeDecoder->Stream.ReadByte(); range <<= 8; }\r
-\r
-#define RC_GETBIT2(numMoveBits, prob, mi, A0, A1) \\r
- { UInt32 bound = (range >> NCompress::NRangeCoder::kNumBitModelTotalBits) * prob; \\r
- if (code < bound) \\r
- { A0; range = bound; \\r
- prob += (NCompress::NRangeCoder::kBitModelTotal - prob) >> numMoveBits; \\r
- mi <<= 1; } \\r
- else \\r
- { A1; range -= bound; code -= bound; prob -= (prob) >> numMoveBits; \\r
- mi = (mi + mi) + 1; }} \\r
- RC_NORMALIZE\r
-\r
-#define RC_GETBIT(numMoveBits, prob, mi) RC_GETBIT2(numMoveBits, prob, mi, ; , ;)\r
-\r
-#endif\r
+++ /dev/null
-// StdAfx.h\r
-\r
-#ifndef __STDAFX_H\r
-#define __STDAFX_H\r
-\r
-#endif\r
+++ /dev/null
-/*
- LzmaDecode.c
- LZMA Decoder (optimized for Speed version)
-
- LZMA SDK 4.22 Copyright (c) 1999-2005 Igor Pavlov (2005-06-10)
- http://www.7-zip.org/
-
- LZMA SDK is licensed under two licenses:
- 1) GNU Lesser General Public License (GNU LGPL)
- 2) Common Public License (CPL)
- It means that you can select one of these two licenses and
- follow rules of that license.
-
- SPECIAL EXCEPTION:
- Igor Pavlov, as the author of this Code, expressly permits you to
- statically or dynamically link your Code (or bind by name) to the
- interfaces of this file without subjecting your linked Code to the
- terms of the CPL or GNU LGPL. Any modifications or additions
- to this file, however, are subject to the LGPL or CPL terms.
-*/
-
-#include "LzmaDecode.h"
-
-#ifndef Byte
-#define Byte unsigned char
-#endif
-
-#define kNumTopBits 24
-#define kTopValue ((UInt32)1 << kNumTopBits)
-
-#define kNumBitModelTotalBits 11
-#define kBitModelTotal (1 << kNumBitModelTotalBits)
-#define kNumMoveBits 5
-
-#define RC_READ_BYTE (*Buffer++)
-
-#define RC_INIT2 Code = 0; Range = 0xFFFFFFFF; \
- { int i; for(i = 0; i < 5; i++) { RC_TEST; Code = (Code << 8) | RC_READ_BYTE; }}
-
-#ifdef _LZMA_IN_CB
-
-#define RC_TEST { if (Buffer == BufferLim) \
- { SizeT size; int result = InCallback->Read(InCallback, &Buffer, &size); if (result != LZMA_RESULT_OK) return result; \
- BufferLim = Buffer + size; if (size == 0) return LZMA_RESULT_DATA_ERROR; }}
-
-#define RC_INIT Buffer = BufferLim = 0; RC_INIT2
-
-#else
-
-#define RC_TEST { if (Buffer == BufferLim) return LZMA_RESULT_DATA_ERROR; }
-
-#define RC_INIT(buffer, bufferSize) Buffer = buffer; BufferLim = buffer + bufferSize; RC_INIT2
-
-#endif
-
-#define RC_NORMALIZE if (Range < kTopValue) { RC_TEST; Range <<= 8; Code = (Code << 8) | RC_READ_BYTE; }
-
-#define IfBit0(p) RC_NORMALIZE; bound = (Range >> kNumBitModelTotalBits) * *(p); if (Code < bound)
-#define UpdateBit0(p) Range = bound; *(p) += (kBitModelTotal - *(p)) >> kNumMoveBits;
-#define UpdateBit1(p) Range -= bound; Code -= bound; *(p) -= (*(p)) >> kNumMoveBits;
-
-#define RC_GET_BIT2(p, mi, A0, A1) IfBit0(p) \
- { UpdateBit0(p); mi <<= 1; A0; } else \
- { UpdateBit1(p); mi = (mi + mi) + 1; A1; }
-
-#define RC_GET_BIT(p, mi) RC_GET_BIT2(p, mi, ; , ;)
-
-#define RangeDecoderBitTreeDecode(probs, numLevels, res) \
- { int i = numLevels; res = 1; \
- do { CProb *p = probs + res; RC_GET_BIT(p, res) } while(--i != 0); \
- res -= (1 << numLevels); }
-
-
-#define kNumPosBitsMax 4
-#define kNumPosStatesMax (1 << kNumPosBitsMax)
-
-#define kLenNumLowBits 3
-#define kLenNumLowSymbols (1 << kLenNumLowBits)
-#define kLenNumMidBits 3
-#define kLenNumMidSymbols (1 << kLenNumMidBits)
-#define kLenNumHighBits 8
-#define kLenNumHighSymbols (1 << kLenNumHighBits)
-
-#define LenChoice 0
-#define LenChoice2 (LenChoice + 1)
-#define LenLow (LenChoice2 + 1)
-#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits))
-#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits))
-#define kNumLenProbs (LenHigh + kLenNumHighSymbols)
-
-
-#define kNumStates 12
-#define kNumLitStates 7
-
-#define kStartPosModelIndex 4
-#define kEndPosModelIndex 14
-#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
-
-#define kNumPosSlotBits 6
-#define kNumLenToPosStates 4
-
-#define kNumAlignBits 4
-#define kAlignTableSize (1 << kNumAlignBits)
-
-#define kMatchMinLen 2
-
-#define IsMatch 0
-#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax))
-#define IsRepG0 (IsRep + kNumStates)
-#define IsRepG1 (IsRepG0 + kNumStates)
-#define IsRepG2 (IsRepG1 + kNumStates)
-#define IsRep0Long (IsRepG2 + kNumStates)
-#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax))
-#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))
-#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex)
-#define LenCoder (Align + kAlignTableSize)
-#define RepLenCoder (LenCoder + kNumLenProbs)
-#define Literal (RepLenCoder + kNumLenProbs)
-
-#if Literal != LZMA_BASE_SIZE
-StopCompilingDueBUG
-#endif
-
-int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size)
-{
- unsigned char prop0;
- if (size < LZMA_PROPERTIES_SIZE)
- return LZMA_RESULT_DATA_ERROR;
- prop0 = propsData[0];
- if (prop0 >= (9 * 5 * 5))
- return LZMA_RESULT_DATA_ERROR;
- {
- for (propsRes->pb = 0; prop0 >= (9 * 5); propsRes->pb++, prop0 -= (9 * 5));
- for (propsRes->lp = 0; prop0 >= 9; propsRes->lp++, prop0 -= 9);
- propsRes->lc = prop0;
- /*
- unsigned char remainder = (unsigned char)(prop0 / 9);
- propsRes->lc = prop0 % 9;
- propsRes->pb = remainder / 5;
- propsRes->lp = remainder % 5;
- */
- }
-
- #ifdef _LZMA_OUT_READ
- {
- int i;
- propsRes->DictionarySize = 0;
- for (i = 0; i < 4; i++)
- propsRes->DictionarySize += (UInt32)(propsData[1 + i]) << (i * 8);
- if (propsRes->DictionarySize == 0)
- propsRes->DictionarySize = 1;
- }
- #endif
- return LZMA_RESULT_OK;
-}
-
-#define kLzmaStreamWasFinishedId (-1)
-
-int LzmaDecode(CLzmaDecoderState *vs,
- #ifdef _LZMA_IN_CB
- ILzmaInCallback *InCallback,
- #else
- const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed,
- #endif
- unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed)
-{
- CProb *p = vs->Probs;
- SizeT nowPos = 0;
- Byte previousByte = 0;
- UInt32 posStateMask = (1 << (vs->Properties.pb)) - 1;
- UInt32 literalPosMask = (1 << (vs->Properties.lp)) - 1;
- int lc = vs->Properties.lc;
-
- #ifdef _LZMA_OUT_READ
-
- UInt32 Range = vs->Range;
- UInt32 Code = vs->Code;
- #ifdef _LZMA_IN_CB
- const Byte *Buffer = vs->Buffer;
- const Byte *BufferLim = vs->BufferLim;
- #else
- const Byte *Buffer = inStream;
- const Byte *BufferLim = inStream + inSize;
- #endif
- int state = vs->State;
- UInt32 rep0 = vs->Reps[0], rep1 = vs->Reps[1], rep2 = vs->Reps[2], rep3 = vs->Reps[3];
- int len = vs->RemainLen;
- UInt32 globalPos = vs->GlobalPos;
- UInt32 distanceLimit = vs->DistanceLimit;
-
- Byte *dictionary = vs->Dictionary;
- UInt32 dictionarySize = vs->Properties.DictionarySize;
- UInt32 dictionaryPos = vs->DictionaryPos;
-
- Byte tempDictionary[4];
-
- #ifndef _LZMA_IN_CB
- *inSizeProcessed = 0;
- #endif
- *outSizeProcessed = 0;
- if (len == kLzmaStreamWasFinishedId)
- return LZMA_RESULT_OK;
-
- if (dictionarySize == 0)
- {
- dictionary = tempDictionary;
- dictionarySize = 1;
- tempDictionary[0] = vs->TempDictionary[0];
- }
-
- if (len == kLzmaNeedInitId)
- {
- {
- UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp));
- UInt32 i;
- for (i = 0; i < numProbs; i++)
- p[i] = kBitModelTotal >> 1;
- rep0 = rep1 = rep2 = rep3 = 1;
- state = 0;
- globalPos = 0;
- distanceLimit = 0;
- dictionaryPos = 0;
- dictionary[dictionarySize - 1] = 0;
- #ifdef _LZMA_IN_CB
- RC_INIT;
- #else
- RC_INIT(inStream, inSize);
- #endif
- }
- len = 0;
- }
- while(len != 0 && nowPos < outSize)
- {
- UInt32 pos = dictionaryPos - rep0;
- if (pos >= dictionarySize)
- pos += dictionarySize;
- outStream[nowPos++] = dictionary[dictionaryPos] = dictionary[pos];
- if (++dictionaryPos == dictionarySize)
- dictionaryPos = 0;
- len--;
- }
- if (dictionaryPos == 0)
- previousByte = dictionary[dictionarySize - 1];
- else
- previousByte = dictionary[dictionaryPos - 1];
-
- #else /* if !_LZMA_OUT_READ */
-
- int state = 0;
- UInt32 rep0 = 1, rep1 = 1, rep2 = 1, rep3 = 1;
- int len = 0;
- const Byte *Buffer;
- const Byte *BufferLim;
- UInt32 Range;
- UInt32 Code;
-
- #ifndef _LZMA_IN_CB
- *inSizeProcessed = 0;
- #endif
- *outSizeProcessed = 0;
-
- {
- UInt32 i;
- UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp));
- for (i = 0; i < numProbs; i++)
- p[i] = kBitModelTotal >> 1;
- }
-
- #ifdef _LZMA_IN_CB
- RC_INIT;
- #else
- RC_INIT(inStream, inSize);
- #endif
-
- #endif /* _LZMA_OUT_READ */
-
- while(nowPos < outSize)
- {
- CProb *prob;
- UInt32 bound;
- int posState = (int)(
- (nowPos
- #ifdef _LZMA_OUT_READ
- + globalPos
- #endif
- )
- & posStateMask);
-
- prob = p + IsMatch + (state << kNumPosBitsMax) + posState;
- IfBit0(prob)
- {
- int symbol = 1;
- UpdateBit0(prob)
- prob = p + Literal + (LZMA_LIT_SIZE *
- (((
- (nowPos
- #ifdef _LZMA_OUT_READ
- + globalPos
- #endif
- )
- & literalPosMask) << lc) + (previousByte >> (8 - lc))));
-
- if (state >= kNumLitStates)
- {
- int matchByte;
- #ifdef _LZMA_OUT_READ
- UInt32 pos = dictionaryPos - rep0;
- if (pos >= dictionarySize)
- pos += dictionarySize;
- matchByte = dictionary[pos];
- #else
- matchByte = outStream[nowPos - rep0];
- #endif
- do
- {
- int bit;
- CProb *probLit;
- matchByte <<= 1;
- bit = (matchByte & 0x100);
- probLit = prob + 0x100 + bit + symbol;
- RC_GET_BIT2(probLit, symbol, if (bit != 0) break, if (bit == 0) break)
- }
- while (symbol < 0x100);
- }
- while (symbol < 0x100)
- {
- CProb *probLit = prob + symbol;
- RC_GET_BIT(probLit, symbol)
- }
- previousByte = (Byte)symbol;
-
- outStream[nowPos++] = previousByte;
- #ifdef _LZMA_OUT_READ
- if (distanceLimit < dictionarySize)
- distanceLimit++;
-
- dictionary[dictionaryPos] = previousByte;
- if (++dictionaryPos == dictionarySize)
- dictionaryPos = 0;
- #endif
- if (state < 4) state = 0;
- else if (state < 10) state -= 3;
- else state -= 6;
- }
- else
- {
- UpdateBit1(prob);
- prob = p + IsRep + state;
- IfBit0(prob)
- {
- UpdateBit0(prob);
- rep3 = rep2;
- rep2 = rep1;
- rep1 = rep0;
- state = state < kNumLitStates ? 0 : 3;
- prob = p + LenCoder;
- }
- else
- {
- UpdateBit1(prob);
- prob = p + IsRepG0 + state;
- IfBit0(prob)
- {
- UpdateBit0(prob);
- prob = p + IsRep0Long + (state << kNumPosBitsMax) + posState;
- IfBit0(prob)
- {
- #ifdef _LZMA_OUT_READ
- UInt32 pos;
- #endif
- UpdateBit0(prob);
-
- #ifdef _LZMA_OUT_READ
- if (distanceLimit == 0)
- #else
- if (nowPos == 0)
- #endif
- return LZMA_RESULT_DATA_ERROR;
-
- state = state < kNumLitStates ? 9 : 11;
- #ifdef _LZMA_OUT_READ
- pos = dictionaryPos - rep0;
- if (pos >= dictionarySize)
- pos += dictionarySize;
- previousByte = dictionary[pos];
- dictionary[dictionaryPos] = previousByte;
- if (++dictionaryPos == dictionarySize)
- dictionaryPos = 0;
- #else
- previousByte = outStream[nowPos - rep0];
- #endif
- outStream[nowPos++] = previousByte;
- #ifdef _LZMA_OUT_READ
- if (distanceLimit < dictionarySize)
- distanceLimit++;
- #endif
-
- continue;
- }
- else
- {
- UpdateBit1(prob);
- }
- }
- else
- {
- UInt32 distance;
- UpdateBit1(prob);
- prob = p + IsRepG1 + state;
- IfBit0(prob)
- {
- UpdateBit0(prob);
- distance = rep1;
- }
- else
- {
- UpdateBit1(prob);
- prob = p + IsRepG2 + state;
- IfBit0(prob)
- {
- UpdateBit0(prob);
- distance = rep2;
- }
- else
- {
- UpdateBit1(prob);
- distance = rep3;
- rep3 = rep2;
- }
- rep2 = rep1;
- }
- rep1 = rep0;
- rep0 = distance;
- }
- state = state < kNumLitStates ? 8 : 11;
- prob = p + RepLenCoder;
- }
- {
- int numBits, offset;
- CProb *probLen = prob + LenChoice;
- IfBit0(probLen)
- {
- UpdateBit0(probLen);
- probLen = prob + LenLow + (posState << kLenNumLowBits);
- offset = 0;
- numBits = kLenNumLowBits;
- }
- else
- {
- UpdateBit1(probLen);
- probLen = prob + LenChoice2;
- IfBit0(probLen)
- {
- UpdateBit0(probLen);
- probLen = prob + LenMid + (posState << kLenNumMidBits);
- offset = kLenNumLowSymbols;
- numBits = kLenNumMidBits;
- }
- else
- {
- UpdateBit1(probLen);
- probLen = prob + LenHigh;
- offset = kLenNumLowSymbols + kLenNumMidSymbols;
- numBits = kLenNumHighBits;
- }
- }
- RangeDecoderBitTreeDecode(probLen, numBits, len);
- len += offset;
- }
-
- if (state < 4)
- {
- int posSlot;
- state += kNumLitStates;
- prob = p + PosSlot +
- ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) <<
- kNumPosSlotBits);
- RangeDecoderBitTreeDecode(prob, kNumPosSlotBits, posSlot);
- if (posSlot >= kStartPosModelIndex)
- {
- int numDirectBits = ((posSlot >> 1) - 1);
- rep0 = (2 | ((UInt32)posSlot & 1));
- if (posSlot < kEndPosModelIndex)
- {
- rep0 <<= numDirectBits;
- prob = p + SpecPos + rep0 - posSlot - 1;
- }
- else
- {
- numDirectBits -= kNumAlignBits;
- do
- {
- RC_NORMALIZE
- Range >>= 1;
- rep0 <<= 1;
- if (Code >= Range)
- {
- Code -= Range;
- rep0 |= 1;
- }
- }
- while (--numDirectBits != 0);
- prob = p + Align;
- rep0 <<= kNumAlignBits;
- numDirectBits = kNumAlignBits;
- }
- {
- int i = 1;
- int mi = 1;
- do
- {
- CProb *prob3 = prob + mi;
- RC_GET_BIT2(prob3, mi, ; , rep0 |= i);
- i <<= 1;
- }
- while(--numDirectBits != 0);
- }
- }
- else
- rep0 = posSlot;
- if (++rep0 == (UInt32)(0))
- {
- /* it's for stream version */
- len = kLzmaStreamWasFinishedId;
- break;
- }
- }
-
- len += kMatchMinLen;
- #ifdef _LZMA_OUT_READ
- if (rep0 > distanceLimit)
- #else
- if (rep0 > nowPos)
- #endif
- return LZMA_RESULT_DATA_ERROR;
-
- #ifdef _LZMA_OUT_READ
- if (dictionarySize - distanceLimit > (UInt32)len)
- distanceLimit += len;
- else
- distanceLimit = dictionarySize;
- #endif
-
- do
- {
- #ifdef _LZMA_OUT_READ
- UInt32 pos = dictionaryPos - rep0;
- if (pos >= dictionarySize)
- pos += dictionarySize;
- previousByte = dictionary[pos];
- dictionary[dictionaryPos] = previousByte;
- if (++dictionaryPos == dictionarySize)
- dictionaryPos = 0;
- #else
- previousByte = outStream[nowPos - rep0];
- #endif
- len--;
- outStream[nowPos++] = previousByte;
- }
- while(len != 0 && nowPos < outSize);
- }
- }
- RC_NORMALIZE;
-
- #ifdef _LZMA_OUT_READ
- vs->Range = Range;
- vs->Code = Code;
- vs->DictionaryPos = dictionaryPos;
- vs->GlobalPos = globalPos + (UInt32)nowPos;
- vs->DistanceLimit = distanceLimit;
- vs->Reps[0] = rep0;
- vs->Reps[1] = rep1;
- vs->Reps[2] = rep2;
- vs->Reps[3] = rep3;
- vs->State = state;
- vs->RemainLen = len;
- vs->TempDictionary[0] = tempDictionary[0];
- #endif
-
- #ifdef _LZMA_IN_CB
- vs->Buffer = Buffer;
- vs->BufferLim = BufferLim;
- #else
- *inSizeProcessed = (SizeT)(Buffer - inStream);
- #endif
- *outSizeProcessed = nowPos;
- return LZMA_RESULT_OK;
-}
+++ /dev/null
-/*
- LzmaDecode.h
- LZMA Decoder interface
-
- LZMA SDK 4.21 Copyright (c) 1999-2005 Igor Pavlov (2005-06-08)
- http://www.7-zip.org/
-
- LZMA SDK is licensed under two licenses:
- 1) GNU Lesser General Public License (GNU LGPL)
- 2) Common Public License (CPL)
- It means that you can select one of these two licenses and
- follow rules of that license.
-
- SPECIAL EXCEPTION:
- Igor Pavlov, as the author of this code, expressly permits you to
- statically or dynamically link your code (or bind by name) to the
- interfaces of this file without subjecting your linked code to the
- terms of the CPL or GNU LGPL. Any modifications or additions
- to this file, however, are subject to the LGPL or CPL terms.
-*/
-
-#ifndef __LZMADECODE_H
-#define __LZMADECODE_H
-
-/* #define _LZMA_IN_CB */
-/* Use callback for input data */
-
-/* #define _LZMA_OUT_READ */
-/* Use read function for output data */
-
-/* #define _LZMA_PROB32 */
-/* It can increase speed on some 32-bit CPUs,
- but memory usage will be doubled in that case */
-
-/* #define _LZMA_LOC_OPT */
-/* Enable local speed optimizations inside code */
-
-/* #define _LZMA_SYSTEM_SIZE_T */
-/* Use system's size_t. You can use it to enable 64-bit sizes supporting*/
-
-#ifndef UInt32
-#ifdef _LZMA_UINT32_IS_ULONG
-#define UInt32 unsigned long
-#else
-#define UInt32 unsigned int
-#endif
-#endif
-
-#ifndef SizeT
-#ifdef _LZMA_SYSTEM_SIZE_T
-#include <stddef.h>
-#define SizeT size_t
-#else
-#define SizeT UInt32
-#endif
-#endif
-
-#ifdef _LZMA_PROB32
-#define CProb UInt32
-#else
-#define CProb unsigned short
-#endif
-
-#define LZMA_RESULT_OK 0
-#define LZMA_RESULT_DATA_ERROR 1
-
-#ifdef _LZMA_IN_CB
-typedef struct _ILzmaInCallback
-{
- int (*Read)(void *object, const unsigned char **buffer, SizeT *bufferSize);
-} ILzmaInCallback;
-#endif
-
-#define LZMA_BASE_SIZE 1846
-#define LZMA_LIT_SIZE 768
-
-#define LZMA_PROPERTIES_SIZE 5
-
-typedef struct _CLzmaProperties
-{
- int lc;
- int lp;
- int pb;
- #ifdef _LZMA_OUT_READ
- UInt32 DictionarySize;
- #endif
-}CLzmaProperties;
-
-int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size);
-
-#define LzmaGetNumProbs(Properties) (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((Properties)->lc + (Properties)->lp)))
-
-#define kLzmaNeedInitId (-2)
-
-typedef struct _CLzmaDecoderState
-{
- CLzmaProperties Properties;
- CProb *Probs;
-
- #ifdef _LZMA_IN_CB
- const unsigned char *Buffer;
- const unsigned char *BufferLim;
- #endif
-
- #ifdef _LZMA_OUT_READ
- unsigned char *Dictionary;
- UInt32 Range;
- UInt32 Code;
- UInt32 DictionaryPos;
- UInt32 GlobalPos;
- UInt32 DistanceLimit;
- UInt32 Reps[4];
- int State;
- int RemainLen;
- unsigned char TempDictionary[4];
- #endif
-} CLzmaDecoderState;
-
-#ifdef _LZMA_OUT_READ
-#define LzmaDecoderInit(vs) { (vs)->RemainLen = kLzmaNeedInitId; }
-#endif
-
-int LzmaDecode(CLzmaDecoderState *vs,
- #ifdef _LZMA_IN_CB
- ILzmaInCallback *inCallback,
- #else
- const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed,
- #endif
- unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed);
-
-#endif
+++ /dev/null
-// ICoder.h\r
-\r
-#ifndef __ICODER_H\r
-#define __ICODER_H\r
-\r
-#include "IStream.h"\r
-\r
-// "23170F69-40C1-278A-0000-000400xx0000"\r
-#define CODER_INTERFACE(i, x) \\r
-DEFINE_GUID(IID_ ## i, \\r
-0x23170F69, 0x40C1, 0x278A, 0x00, 0x00, 0x00, 0x04, 0x00, x, 0x00, 0x00); \\r
-struct i: public IUnknown\r
-\r
-CODER_INTERFACE(ICompressProgressInfo, 0x04)\r
-{\r
- STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize) PURE;\r
-};\r
-\r
-CODER_INTERFACE(ICompressCoder, 0x05)\r
-{\r
- STDMETHOD(Code)(ISequentialInStream *inStream,\r
- ISequentialOutStream *outStream, \r
- const UInt64 *inSize, \r
- const UInt64 *outSize,\r
- ICompressProgressInfo *progress) PURE;\r
-};\r
-\r
-CODER_INTERFACE(ICompressCoder2, 0x18)\r
-{\r
- STDMETHOD(Code)(ISequentialInStream **inStreams,\r
- const UInt64 **inSizes, \r
- UInt32 numInStreams,\r
- ISequentialOutStream **outStreams, \r
- const UInt64 **outSizes,\r
- UInt32 numOutStreams,\r
- ICompressProgressInfo *progress) PURE;\r
-};\r
-\r
-namespace NCoderPropID\r
-{\r
- enum EEnum\r
- {\r
- kDictionarySize = 0x400,\r
- kUsedMemorySize,\r
- kOrder,\r
- kPosStateBits = 0x440,\r
- kLitContextBits,\r
- kLitPosBits,\r
- kNumFastBytes = 0x450,\r
- kMatchFinder,\r
- kMatchFinderCycles,\r
- kNumPasses = 0x460, \r
- kAlgorithm = 0x470,\r
- kMultiThread = 0x480,\r
- kNumThreads,\r
- kEndMarker = 0x490\r
- };\r
-}\r
-\r
-CODER_INTERFACE(ICompressSetCoderProperties, 0x20)\r
-{\r
- STDMETHOD(SetCoderProperties)(const PROPID *propIDs, \r
- const PROPVARIANT *properties, UInt32 numProperties) PURE;\r
-};\r
-\r
-/*\r
-CODER_INTERFACE(ICompressSetCoderProperties, 0x21)\r
-{\r
- STDMETHOD(SetDecoderProperties)(ISequentialInStream *inStream) PURE;\r
-};\r
-*/\r
-\r
-CODER_INTERFACE(ICompressSetDecoderProperties2, 0x22)\r
-{\r
- STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size) PURE;\r
-};\r
-\r
-CODER_INTERFACE(ICompressWriteCoderProperties, 0x23)\r
-{\r
- STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStreams) PURE;\r
-};\r
-\r
-CODER_INTERFACE(ICompressGetInStreamProcessedSize, 0x24)\r
-{\r
- STDMETHOD(GetInStreamProcessedSize)(UInt64 *value) PURE;\r
-};\r
-\r
-CODER_INTERFACE(ICompressSetCoderMt, 0x25)\r
-{\r
- STDMETHOD(SetNumberOfThreads)(UInt32 numThreads) PURE;\r
-};\r
-\r
-CODER_INTERFACE(ICompressGetSubStreamSize, 0x30)\r
-{\r
- STDMETHOD(GetSubStreamSize)(UInt64 subStream, UInt64 *value) PURE;\r
-};\r
-\r
-CODER_INTERFACE(ICompressSetInStream, 0x31)\r
-{\r
- STDMETHOD(SetInStream)(ISequentialInStream *inStream) PURE;\r
- STDMETHOD(ReleaseInStream)() PURE;\r
-};\r
-\r
-CODER_INTERFACE(ICompressSetOutStream, 0x32)\r
-{\r
- STDMETHOD(SetOutStream)(ISequentialOutStream *outStream) PURE;\r
- STDMETHOD(ReleaseOutStream)() PURE;\r
-};\r
-\r
-CODER_INTERFACE(ICompressSetInStreamSize, 0x33)\r
-{\r
- STDMETHOD(SetInStreamSize)(const UInt64 *inSize) PURE;\r
-};\r
-\r
-CODER_INTERFACE(ICompressSetOutStreamSize, 0x34)\r
-{\r
- STDMETHOD(SetOutStreamSize)(const UInt64 *outSize) PURE;\r
-};\r
-\r
-CODER_INTERFACE(ICompressFilter, 0x40)\r
-{\r
- STDMETHOD(Init)() PURE;\r
- STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size) PURE;\r
- // Filter return outSize (UInt32)\r
- // if (outSize <= size): Filter have converted outSize bytes\r
- // if (outSize > size): Filter have not converted anything.\r
- // and it needs at least outSize bytes to convert one block \r
- // (it's for crypto block algorithms).\r
-};\r
-\r
-CODER_INTERFACE(ICryptoProperties, 0x80)\r
-{\r
- STDMETHOD(SetKey)(const Byte *data, UInt32 size) PURE;\r
- STDMETHOD(SetInitVector)(const Byte *data, UInt32 size) PURE;\r
-};\r
-\r
-CODER_INTERFACE(ICryptoSetPassword, 0x90)\r
-{\r
- STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size) PURE;\r
-};\r
-\r
-CODER_INTERFACE(ICryptoSetCRC, 0xA0)\r
-{\r
- STDMETHOD(CryptoSetCRC)(UInt32 crc) PURE;\r
-};\r
-\r
-//////////////////////\r
-// It's for DLL file\r
-namespace NMethodPropID\r
-{\r
- enum EEnum\r
- {\r
- kID,\r
- kName,\r
- kDecoder,\r
- kEncoder,\r
- kInStreams,\r
- kOutStreams,\r
- kDescription\r
- };\r
-}\r
-\r
-#endif\r
+++ /dev/null
-// IStream.h\r
-\r
-#ifndef __ISTREAM_H\r
-#define __ISTREAM_H\r
-\r
-#include "../Common/MyUnknown.h"\r
-#include "../Common/Types.h"\r
-\r
-// "23170F69-40C1-278A-0000-000300xx0000"\r
-\r
-#define STREAM_INTERFACE_SUB(i, b, x) \\r
-DEFINE_GUID(IID_ ## i, \\r
-0x23170F69, 0x40C1, 0x278A, 0x00, 0x00, 0x00, 0x03, 0x00, x, 0x00, 0x00); \\r
-struct i: public b\r
-\r
-#define STREAM_INTERFACE(i, x) STREAM_INTERFACE_SUB(i, IUnknown, x)\r
-\r
-STREAM_INTERFACE(ISequentialInStream, 0x01)\r
-{\r
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize) PURE;\r
- /*\r
- Out: if size != 0, return_value = S_OK and (*processedSize == 0),\r
- then there are no more bytes in stream.\r
- if (size > 0) && there are bytes in stream, \r
- this function must read at least 1 byte.\r
- This function is allowed to read less than number of remaining bytes in stream.\r
- You must call Read function in loop, if you need exact amount of data\r
- */\r
-};\r
-\r
-STREAM_INTERFACE(ISequentialOutStream, 0x02)\r
-{\r
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize) PURE;\r
- /*\r
- if (size > 0) this function must write at least 1 byte.\r
- This function is allowed to write less than "size".\r
- You must call Write function in loop, if you need to write exact amount of data\r
- */\r
-};\r
-\r
-STREAM_INTERFACE_SUB(IInStream, ISequentialInStream, 0x03)\r
-{\r
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) PURE;\r
-};\r
-\r
-STREAM_INTERFACE_SUB(IOutStream, ISequentialOutStream, 0x04)\r
-{\r
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) PURE;\r
- STDMETHOD(SetSize)(Int64 newSize) PURE;\r
-};\r
-\r
-STREAM_INTERFACE(IStreamGetSize, 0x06)\r
-{\r
- STDMETHOD(GetSize)(UInt64 *size) PURE;\r
-};\r
-\r
-STREAM_INTERFACE(IOutStreamFlush, 0x07)\r
-{\r
- STDMETHOD(Flush)() PURE;\r
-};\r
-\r
-#endif\r
+++ /dev/null
-// Common/Alloc.cpp\r
-\r
-#include "StdAfx.h"\r
-\r
-#ifdef _WIN32\r
-#include "MyWindows.h"\r
-#else\r
-#include <stdlib.h>\r
-#endif\r
-\r
-#include "Alloc.h"\r
-\r
-/* #define _SZ_ALLOC_DEBUG */\r
-/* use _SZ_ALLOC_DEBUG to debug alloc/free operations */\r
-#ifdef _SZ_ALLOC_DEBUG\r
-#include <stdio.h>\r
-int g_allocCount = 0;\r
-int g_allocCountMid = 0;\r
-int g_allocCountBig = 0;\r
-#endif\r
-\r
-void *MyAlloc(size_t size) throw()\r
-{\r
- if (size == 0)\r
- return 0;\r
- #ifdef _SZ_ALLOC_DEBUG\r
- fprintf(stderr, "\nAlloc %10d bytes; count = %10d", size, g_allocCount++);\r
- #endif\r
- return ::malloc(size);\r
-}\r
-\r
-void MyFree(void *address) throw()\r
-{\r
- #ifdef _SZ_ALLOC_DEBUG\r
- if (address != 0)\r
- fprintf(stderr, "\nFree; count = %10d", --g_allocCount);\r
- #endif\r
- \r
- ::free(address);\r
-}\r
-\r
-#ifdef _WIN32\r
-\r
-void *MidAlloc(size_t size) throw()\r
-{\r
- if (size == 0)\r
- return 0;\r
- #ifdef _SZ_ALLOC_DEBUG\r
- fprintf(stderr, "\nAlloc_Mid %10d bytes; count = %10d", size, g_allocCountMid++);\r
- #endif\r
- return ::VirtualAlloc(0, size, MEM_COMMIT, PAGE_READWRITE);\r
-}\r
-\r
-void MidFree(void *address) throw()\r
-{\r
- #ifdef _SZ_ALLOC_DEBUG\r
- if (address != 0)\r
- fprintf(stderr, "\nFree_Mid; count = %10d", --g_allocCountMid);\r
- #endif\r
- if (address == 0)\r
- return;\r
- ::VirtualFree(address, 0, MEM_RELEASE);\r
-}\r
-\r
-static SIZE_T g_LargePageSize = \r
- #ifdef _WIN64\r
- (1 << 21);\r
- #else\r
- (1 << 22);\r
- #endif\r
-\r
-typedef SIZE_T (WINAPI *GetLargePageMinimumP)();\r
-\r
-bool SetLargePageSize()\r
-{\r
- GetLargePageMinimumP largePageMinimum = (GetLargePageMinimumP)\r
- ::GetProcAddress(::GetModuleHandle(TEXT("kernel32.dll")), "GetLargePageMinimum");\r
- if (largePageMinimum == 0)\r
- return false;\r
- SIZE_T size = largePageMinimum();\r
- if (size == 0 || (size & (size - 1)) != 0)\r
- return false;\r
- g_LargePageSize = size;\r
- return true;\r
-}\r
-\r
-\r
-void *BigAlloc(size_t size) throw()\r
-{\r
- if (size == 0)\r
- return 0;\r
- #ifdef _SZ_ALLOC_DEBUG\r
- fprintf(stderr, "\nAlloc_Big %10d bytes; count = %10d", size, g_allocCountBig++);\r
- #endif\r
- \r
- if (size >= (1 << 18))\r
- {\r
- void *res = ::VirtualAlloc(0, (size + g_LargePageSize - 1) & (~(g_LargePageSize - 1)), \r
- MEM_COMMIT | MEM_LARGE_PAGES, PAGE_READWRITE);\r
- if (res != 0)\r
- return res;\r
- }\r
- return ::VirtualAlloc(0, size, MEM_COMMIT, PAGE_READWRITE);\r
-}\r
-\r
-void BigFree(void *address) throw()\r
-{\r
- #ifdef _SZ_ALLOC_DEBUG\r
- if (address != 0)\r
- fprintf(stderr, "\nFree_Big; count = %10d", --g_allocCountBig);\r
- #endif\r
- \r
- if (address == 0)\r
- return;\r
- ::VirtualFree(address, 0, MEM_RELEASE);\r
-}\r
-\r
-#endif\r
+++ /dev/null
-// Common/Alloc.h\r
-\r
-#ifndef __COMMON_ALLOC_H\r
-#define __COMMON_ALLOC_H\r
-\r
-#include <stddef.h>\r
-\r
-void *MyAlloc(size_t size) throw();\r
-void MyFree(void *address) throw();\r
-\r
-#ifdef _WIN32\r
-\r
-bool SetLargePageSize();\r
-\r
-void *MidAlloc(size_t size) throw();\r
-void MidFree(void *address) throw();\r
-void *BigAlloc(size_t size) throw();\r
-void BigFree(void *address) throw();\r
-\r
-#else\r
-\r
-#define MidAlloc(size) MyAlloc(size)\r
-#define MidFree(address) MyFree(address)\r
-#define BigAlloc(size) MyAlloc(size)\r
-#define BigFree(address) MyFree(address)\r
-\r
-#endif\r
-\r
-#endif\r
+++ /dev/null
-// Common/CRC.cpp\r
-\r
-#include "StdAfx.h"\r
-\r
-#include "CRC.h"\r
-\r
-static const UInt32 kCRCPoly = 0xEDB88320;\r
-\r
-UInt32 CCRC::Table[256];\r
-\r
-void CCRC::InitTable()\r
-{\r
- for (UInt32 i = 0; i < 256; i++)\r
- {\r
- UInt32 r = i;\r
- for (int j = 0; j < 8; j++)\r
- if (r & 1) \r
- r = (r >> 1) ^ kCRCPoly;\r
- else \r
- r >>= 1;\r
- CCRC::Table[i] = r;\r
- }\r
-}\r
-\r
-class CCRCTableInit\r
-{\r
-public:\r
- CCRCTableInit() { CCRC::InitTable(); }\r
-} g_CRCTableInit;\r
-\r
-void CCRC::UpdateByte(Byte b)\r
-{\r
- _value = Table[((Byte)(_value)) ^ b] ^ (_value >> 8);\r
-}\r
-\r
-void CCRC::UpdateUInt16(UInt16 v)\r
-{\r
- UpdateByte(Byte(v));\r
- UpdateByte(Byte(v >> 8));\r
-}\r
-\r
-void CCRC::UpdateUInt32(UInt32 v)\r
-{\r
- for (int i = 0; i < 4; i++)\r
- UpdateByte((Byte)(v >> (8 * i)));\r
-}\r
-\r
-void CCRC::UpdateUInt64(UInt64 v)\r
-{\r
- for (int i = 0; i < 8; i++)\r
- UpdateByte((Byte)(v >> (8 * i)));\r
-}\r
-\r
-void CCRC::Update(const void *data, size_t size)\r
-{\r
- UInt32 v = _value;\r
- const Byte *p = (const Byte *)data;\r
- for (; size > 0 ; size--, p++)\r
- v = Table[((Byte)(v)) ^ *p] ^ (v >> 8);\r
- _value = v;\r
-}\r
+++ /dev/null
-// Common/CRC.h\r
-\r
-#ifndef __COMMON_CRC_H\r
-#define __COMMON_CRC_H\r
-\r
-#include <stddef.h>\r
-#include "Types.h"\r
-\r
-class CCRC\r
-{\r
- UInt32 _value;\r
-public:\r
- static UInt32 Table[256];\r
- static void InitTable();\r
-\r
- CCRC(): _value(0xFFFFFFFF){};\r
- void Init() { _value = 0xFFFFFFFF; }\r
- void UpdateByte(Byte v);\r
- void UpdateUInt16(UInt16 v);\r
- void UpdateUInt32(UInt32 v);\r
- void UpdateUInt64(UInt64 v);\r
- void Update(const void *data, size_t size);\r
- UInt32 GetDigest() const { return _value ^ 0xFFFFFFFF; } \r
- static UInt32 CalculateDigest(const void *data, size_t size)\r
- {\r
- CCRC crc;\r
- crc.Update(data, size);\r
- return crc.GetDigest();\r
- }\r
- static bool VerifyDigest(UInt32 digest, const void *data, size_t size)\r
- {\r
- return (CalculateDigest(data, size) == digest);\r
- }\r
-};\r
-\r
-#endif\r
+++ /dev/null
-// Common/Defs.h\r
-\r
-#ifndef __COMMON_DEFS_H\r
-#define __COMMON_DEFS_H\r
-\r
-template <class T> inline T MyMin(T a, T b)\r
- { return a < b ? a : b; }\r
-template <class T> inline T MyMax(T a, T b)\r
- { return a > b ? a : b; }\r
-\r
-template <class T> inline int MyCompare(T a, T b)\r
- { return a < b ? -1 : (a == b ? 0 : 1); }\r
-\r
-inline int BoolToInt(bool value)\r
- { return (value ? 1: 0); }\r
-\r
-inline bool IntToBool(int value)\r
- { return (value != 0); }\r
-\r
-#endif\r
+++ /dev/null
-// MyCom.h\r
-\r
-#ifndef __MYCOM_H\r
-#define __MYCOM_H\r
-\r
-#include "MyWindows.h"\r
-\r
-#define RINOK(x) { HRESULT __result_ = (x); if(__result_ != S_OK) return __result_; }\r
-\r
-template <class T>\r
-class CMyComPtr\r
-{\r
- T* _p;\r
-public:\r
- // typedef T _PtrClass;\r
- CMyComPtr() { _p = NULL;}\r
- CMyComPtr(T* p) {if ((_p = p) != NULL) p->AddRef(); }\r
- CMyComPtr(const CMyComPtr<T>& lp)\r
- {\r
- if ((_p = lp._p) != NULL)\r
- _p->AddRef();\r
- }\r
- ~CMyComPtr() { if (_p) _p->Release(); }\r
- void Release() { if (_p) { _p->Release(); _p = NULL; } }\r
- operator T*() const { return (T*)_p; }\r
- // T& operator*() const { return *_p; }\r
- T** operator&() { return &_p; }\r
- T* operator->() const { return _p; }\r
- T* operator=(T* p) \r
- { \r
- if (p != 0)\r
- p->AddRef();\r
- if (_p) \r
- _p->Release();\r
- _p = p;\r
- return p;\r
- }\r
- T* operator=(const CMyComPtr<T>& lp) { return (*this = lp._p); }\r
- bool operator!() const { return (_p == NULL); }\r
- // bool operator==(T* pT) const { return _p == pT; }\r
- // Compare two objects for equivalence\r
- void Attach(T* p2)\r
- {\r
- Release();\r
- _p = p2;\r
- }\r
- T* Detach()\r
- {\r
- T* pt = _p;\r
- _p = NULL;\r
- return pt;\r
- }\r
- #ifdef _WIN32\r
- HRESULT CoCreateInstance(REFCLSID rclsid, REFIID iid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)\r
- {\r
- return ::CoCreateInstance(rclsid, pUnkOuter, dwClsContext, iid, (void**)&_p);\r
- }\r
- #endif\r
- /*\r
- HRESULT CoCreateInstance(LPCOLESTR szProgID, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)\r
- {\r
- CLSID clsid;\r
- HRESULT hr = CLSIDFromProgID(szProgID, &clsid);\r
- ATLASSERT(_p == NULL);\r
- if (SUCCEEDED(hr))\r
- hr = ::CoCreateInstance(clsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&_p);\r
- return hr;\r
- }\r
- */\r
- template <class Q>\r
- HRESULT QueryInterface(REFGUID iid, Q** pp) const\r
- {\r
- return _p->QueryInterface(iid, (void**)pp);\r
- }\r
-};\r
-\r
-//////////////////////////////////////////////////////////\r
-\r
-class CMyComBSTR\r
-{\r
-public:\r
- BSTR m_str;\r
- CMyComBSTR() { m_str = NULL; }\r
- CMyComBSTR(LPCOLESTR pSrc) { m_str = ::SysAllocString(pSrc); }\r
- // CMyComBSTR(int nSize) { m_str = ::SysAllocStringLen(NULL, nSize); }\r
- // CMyComBSTR(int nSize, LPCOLESTR sz) { m_str = ::SysAllocStringLen(sz, nSize); }\r
- CMyComBSTR(const CMyComBSTR& src) { m_str = src.MyCopy(); }\r
- /*\r
- CMyComBSTR(REFGUID src)\r
- {\r
- LPOLESTR szGuid;\r
- StringFromCLSID(src, &szGuid);\r
- m_str = ::SysAllocString(szGuid);\r
- CoTaskMemFree(szGuid);\r
- }\r
- */\r
- ~CMyComBSTR() { ::SysFreeString(m_str); }\r
- CMyComBSTR& operator=(const CMyComBSTR& src)\r
- {\r
- if (m_str != src.m_str)\r
- {\r
- if (m_str)\r
- ::SysFreeString(m_str);\r
- m_str = src.MyCopy();\r
- }\r
- return *this;\r
- }\r
- CMyComBSTR& operator=(LPCOLESTR pSrc)\r
- {\r
- ::SysFreeString(m_str);\r
- m_str = ::SysAllocString(pSrc);\r
- return *this;\r
- }\r
- unsigned int Length() const { return ::SysStringLen(m_str); }\r
- operator BSTR() const { return m_str; }\r
- BSTR* operator&() { return &m_str; }\r
- BSTR MyCopy() const \r
- { \r
- int byteLen = ::SysStringByteLen(m_str);\r
- BSTR res = ::SysAllocStringByteLen(NULL, byteLen);\r
- memmove(res, m_str, byteLen);\r
- return res;\r
- }\r
- void Attach(BSTR src) { m_str = src; }\r
- BSTR Detach()\r
- {\r
- BSTR s = m_str;\r
- m_str = NULL;\r
- return s;\r
- }\r
- void Empty()\r
- {\r
- ::SysFreeString(m_str);\r
- m_str = NULL;\r
- }\r
- bool operator!() const { return (m_str == NULL); }\r
-};\r
-\r
-\r
-//////////////////////////////////////////////////////////\r
-\r
-class CMyUnknownImp\r
-{\r
-public:\r
- ULONG __m_RefCount;\r
- CMyUnknownImp(): __m_RefCount(0) {}\r
-};\r
-\r
-#define MY_QUERYINTERFACE_BEGIN STDMETHOD(QueryInterface) \\r
- (REFGUID iid, void **outObject) { \r
-\r
-#define MY_QUERYINTERFACE_ENTRY(i) if (iid == IID_ ## i) \\r
- { *outObject = (void *)(i *)this; AddRef(); return S_OK; }\r
-\r
-#define MY_QUERYINTERFACE_END return E_NOINTERFACE; }\r
-\r
-#define MY_ADDREF_RELEASE \\r
-STDMETHOD_(ULONG, AddRef)() { return ++__m_RefCount; } \\r
-STDMETHOD_(ULONG, Release)() { if (--__m_RefCount != 0) \\r
- return __m_RefCount; delete this; return 0; }\r
-\r
-#define MY_UNKNOWN_IMP_SPEC(i) \\r
- MY_QUERYINTERFACE_BEGIN \\r
- i \\r
- MY_QUERYINTERFACE_END \\r
- MY_ADDREF_RELEASE\r
-\r
-\r
-#define MY_UNKNOWN_IMP STDMETHOD(QueryInterface)(REFGUID, void **) { \\r
- MY_QUERYINTERFACE_END \\r
- MY_ADDREF_RELEASE\r
-\r
-#define MY_UNKNOWN_IMP1(i) MY_UNKNOWN_IMP_SPEC( \\r
- MY_QUERYINTERFACE_ENTRY(i) \\r
- )\r
-\r
-#define MY_UNKNOWN_IMP2(i1, i2) MY_UNKNOWN_IMP_SPEC( \\r
- MY_QUERYINTERFACE_ENTRY(i1) \\r
- MY_QUERYINTERFACE_ENTRY(i2) \\r
- )\r
-\r
-#define MY_UNKNOWN_IMP3(i1, i2, i3) MY_UNKNOWN_IMP_SPEC( \\r
- MY_QUERYINTERFACE_ENTRY(i1) \\r
- MY_QUERYINTERFACE_ENTRY(i2) \\r
- MY_QUERYINTERFACE_ENTRY(i3) \\r
- )\r
-\r
-#define MY_UNKNOWN_IMP4(i1, i2, i3, i4) MY_UNKNOWN_IMP_SPEC( \\r
- MY_QUERYINTERFACE_ENTRY(i1) \\r
- MY_QUERYINTERFACE_ENTRY(i2) \\r
- MY_QUERYINTERFACE_ENTRY(i3) \\r
- MY_QUERYINTERFACE_ENTRY(i4) \\r
- )\r
-\r
-#define MY_UNKNOWN_IMP5(i1, i2, i3, i4, i5) MY_UNKNOWN_IMP_SPEC( \\r
- MY_QUERYINTERFACE_ENTRY(i1) \\r
- MY_QUERYINTERFACE_ENTRY(i2) \\r
- MY_QUERYINTERFACE_ENTRY(i3) \\r
- MY_QUERYINTERFACE_ENTRY(i4) \\r
- MY_QUERYINTERFACE_ENTRY(i5) \\r
- )\r
-\r
-#endif\r
+++ /dev/null
-// Common/MyGuidDef.h\r
-\r
-#ifndef GUID_DEFINED\r
-#define GUID_DEFINED\r
-\r
-#include "Types.h"\r
-\r
-typedef struct {\r
- UInt32 Data1;\r
- UInt16 Data2;\r
- UInt16 Data3;\r
- unsigned char Data4[8];\r
-} GUID;\r
-\r
-#ifdef __cplusplus\r
-#define REFGUID const GUID &\r
-#else\r
-#define REFGUID const GUID *\r
-#endif\r
-\r
-#define REFCLSID REFGUID\r
-#define REFIID REFGUID\r
-\r
-#ifdef __cplusplus\r
-inline bool operator==(REFGUID g1, REFGUID g2)\r
-{ \r
- for (int i = 0; i < (int)sizeof(g1); i++)\r
- if (((const unsigned char *)&g1)[i] != ((const unsigned char *)&g2)[i])\r
- return false;\r
- return true;\r
-}\r
-inline bool operator!=(REFGUID g1, REFGUID g2) { return !(g1 == g2); }\r
-#endif\r
-\r
-#ifdef __cplusplus\r
- #define MY_EXTERN_C extern "C"\r
-#else\r
- #define MY_EXTERN_C extern\r
-#endif\r
-\r
-#endif // GUID_DEFINED\r
-\r
-\r
-#ifdef DEFINE_GUID\r
-#undef DEFINE_GUID\r
-#endif\r
-\r
-#ifdef INITGUID\r
- #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \\r
- MY_EXTERN_C const GUID name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }\r
-#else\r
- #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \\r
- MY_EXTERN_C const GUID name\r
-#endif\r
+++ /dev/null
-// Common/MyInitGuid.h\r
-\r
-#ifndef __COMMON_MYINITGUID_H\r
-#define __COMMON_MYINITGUID_H\r
-\r
-#ifdef _WIN32\r
-#include <initguid.h>\r
-#else\r
-#define INITGUID\r
-#include "MyGuidDef.h"\r
-#endif\r
-\r
-#endif\r
+++ /dev/null
-// MyUnknown.h\r
-\r
-#ifndef __MYUNKNOWN_H\r
-#define __MYUNKNOWN_H\r
-\r
-#ifdef _WIN32\r
-\r
-#ifdef _WIN32_WCE\r
-#if (_WIN32_WCE > 300)\r
-#include <basetyps.h>\r
-#else\r
-#define MIDL_INTERFACE(x) struct \r
-#endif\r
-#else\r
-#include <basetyps.h>\r
-#endif\r
-\r
-#include <unknwn.h>\r
-\r
-#else \r
-#include "MyWindows.h"\r
-#endif\r
- \r
-#endif\r
+++ /dev/null
-// MyWindows.h\r
-\r
-#ifndef __MYWINDOWS_H\r
-#define __MYWINDOWS_H\r
-\r
-#ifdef _WIN32\r
-\r
-#include <windows.h>\r
-\r
-#define CHAR_PATH_SEPARATOR '\\'\r
-#define WCHAR_PATH_SEPARATOR L'\\'\r
-#define STRING_PATH_SEPARATOR "\\"\r
-#define WSTRING_PATH_SEPARATOR L"\\"\r
-\r
-#else\r
-\r
-#define CHAR_PATH_SEPARATOR '/'\r
-#define WCHAR_PATH_SEPARATOR L'/'\r
-#define STRING_PATH_SEPARATOR "/"\r
-#define WSTRING_PATH_SEPARATOR L"/"\r
-\r
-#include <stddef.h> // for wchar_t\r
-#include <string.h>\r
-\r
-#include "MyGuidDef.h"\r
-\r
-typedef char CHAR;\r
-typedef unsigned char UCHAR;\r
-\r
-#undef BYTE\r
-typedef unsigned char BYTE;\r
-\r
-typedef short SHORT;\r
-typedef unsigned short USHORT;\r
-\r
-#undef WORD\r
-typedef unsigned short WORD;\r
-typedef short VARIANT_BOOL;\r
-\r
-typedef int INT;\r
-typedef Int32 INT32;\r
-typedef unsigned int UINT;\r
-typedef UInt32 UINT32;\r
-typedef INT32 LONG; // LONG, ULONG and DWORD must be 32-bit\r
-typedef UINT32 ULONG;\r
-\r
-#undef DWORD\r
-typedef UINT32 DWORD;\r
-\r
-typedef Int64 LONGLONG;\r
-typedef UInt64 ULONGLONG;\r
-\r
-typedef struct LARGE_INTEGER { LONGLONG QuadPart; }LARGE_INTEGER;\r
-typedef struct _ULARGE_INTEGER { ULONGLONG QuadPart;} ULARGE_INTEGER;\r
-\r
-typedef const CHAR *LPCSTR;\r
-typedef CHAR TCHAR;\r
-typedef const TCHAR *LPCTSTR;\r
-typedef wchar_t WCHAR;\r
-typedef WCHAR OLECHAR;\r
-typedef const WCHAR *LPCWSTR;\r
-typedef OLECHAR *BSTR;\r
-typedef const OLECHAR *LPCOLESTR;\r
-typedef OLECHAR *LPOLESTR;\r
-\r
-typedef struct _FILETIME\r
-{\r
- DWORD dwLowDateTime;\r
- DWORD dwHighDateTime;\r
-}FILETIME;\r
-\r
-#define HRESULT LONG\r
-#define FAILED(Status) ((HRESULT)(Status)<0)\r
-typedef ULONG PROPID;\r
-typedef LONG SCODE;\r
-\r
-#define S_OK ((HRESULT)0x00000000L)\r
-#define S_FALSE ((HRESULT)0x00000001L)\r
-#define E_NOTIMPL ((HRESULT)0x80004001L)\r
-#define E_NOINTERFACE ((HRESULT)0x80004002L)\r
-#define E_ABORT ((HRESULT)0x80004004L)\r
-#define E_FAIL ((HRESULT)0x80004005L)\r
-#define STG_E_INVALIDFUNCTION ((HRESULT)0x80030001L)\r
-#define E_OUTOFMEMORY ((HRESULT)0x8007000EL)\r
-#define E_INVALIDARG ((HRESULT)0x80070057L)\r
-\r
-#ifdef _MSC_VER\r
-#define STDMETHODCALLTYPE __stdcall \r
-#else\r
-#define STDMETHODCALLTYPE \r
-#endif\r
-\r
-#define STDMETHOD_(t, f) virtual t STDMETHODCALLTYPE f\r
-#define STDMETHOD(f) STDMETHOD_(HRESULT, f)\r
-#define STDMETHODIMP_(type) type STDMETHODCALLTYPE\r
-#define STDMETHODIMP STDMETHODIMP_(HRESULT)\r
-\r
-#define PURE = 0\r
-\r
-#define MIDL_INTERFACE(x) struct \r
-\r
-struct IUnknown\r
-{\r
- //virtual ~IUnknown() {}\r
- STDMETHOD(QueryInterface) (REFIID iid, void **outObject) PURE;\r
- STDMETHOD_(ULONG, AddRef)() PURE;\r
- STDMETHOD_(ULONG, Release)() PURE;\r
-};\r
-\r
-typedef IUnknown *LPUNKNOWN;\r
-\r
-#define VARIANT_TRUE ((VARIANT_BOOL)-1)\r
-#define VARIANT_FALSE ((VARIANT_BOOL)0)\r
-\r
-enum VARENUM\r
-{ \r
- VT_EMPTY = 0,\r
- VT_NULL = 1,\r
- VT_I2 = 2,\r
- VT_I4 = 3,\r
- VT_R4 = 4,\r
- VT_R8 = 5,\r
- VT_CY = 6,\r
- VT_DATE = 7,\r
- VT_BSTR = 8,\r
- VT_DISPATCH = 9,\r
- VT_ERROR = 10,\r
- VT_BOOL = 11,\r
- VT_VARIANT = 12,\r
- VT_UNKNOWN = 13,\r
- VT_DECIMAL = 14,\r
- VT_I1 = 16,\r
- VT_UI1 = 17,\r
- VT_UI2 = 18,\r
- VT_UI4 = 19,\r
- VT_I8 = 20,\r
- VT_UI8 = 21,\r
- VT_INT = 22,\r
- VT_UINT = 23,\r
- VT_VOID = 24,\r
- VT_HRESULT = 25,\r
- VT_FILETIME = 64\r
-};\r
-\r
-typedef unsigned short VARTYPE;\r
-typedef WORD PROPVAR_PAD1;\r
-typedef WORD PROPVAR_PAD2;\r
-typedef WORD PROPVAR_PAD3;\r
-\r
-typedef struct tagPROPVARIANT\r
-{\r
- VARTYPE vt;\r
- PROPVAR_PAD1 wReserved1;\r
- PROPVAR_PAD2 wReserved2;\r
- PROPVAR_PAD3 wReserved3;\r
- union \r
- {\r
- CHAR cVal;\r
- UCHAR bVal;\r
- SHORT iVal;\r
- USHORT uiVal;\r
- LONG lVal;\r
- ULONG ulVal;\r
- INT intVal;\r
- UINT uintVal;\r
- LARGE_INTEGER hVal;\r
- ULARGE_INTEGER uhVal;\r
- VARIANT_BOOL boolVal;\r
- SCODE scode;\r
- FILETIME filetime;\r
- BSTR bstrVal;\r
- };\r
-} PROPVARIANT;\r
-\r
-typedef PROPVARIANT tagVARIANT;\r
-typedef tagVARIANT VARIANT;\r
-typedef VARIANT VARIANTARG;\r
-\r
-MY_EXTERN_C BSTR SysAllocStringByteLen(LPCSTR psz, UINT len);\r
-MY_EXTERN_C BSTR SysAllocString(const OLECHAR *sz);\r
-MY_EXTERN_C void SysFreeString(BSTR bstr);\r
-MY_EXTERN_C UINT SysStringByteLen(BSTR bstr);\r
-MY_EXTERN_C UINT SysStringLen(BSTR bstr);\r
-\r
-MY_EXTERN_C DWORD GetLastError();\r
-MY_EXTERN_C HRESULT VariantClear(VARIANTARG *prop);\r
-MY_EXTERN_C HRESULT VariantCopy(VARIANTARG *dest, VARIANTARG *src);\r
-MY_EXTERN_C LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2);\r
-\r
-#define CP_ACP 0\r
-#define CP_OEMCP 1\r
-\r
-typedef enum tagSTREAM_SEEK\r
-{ \r
- STREAM_SEEK_SET = 0,\r
- STREAM_SEEK_CUR = 1,\r
- STREAM_SEEK_END = 2\r
-} STREAM_SEEK;\r
-\r
-#endif\r
-#endif\r
+++ /dev/null
-// Common/NewHandler.h\r
-\r
-#ifndef __COMMON_NEWHANDLER_H\r
-#define __COMMON_NEWHANDLER_H\r
-\r
-class CNewException {};\r
-\r
-#ifdef _WIN32\r
-void \r
-#ifdef _MSC_VER\r
-__cdecl \r
-#endif\r
-operator delete(void *p) throw();\r
-#endif \r
-\r
-#endif \r
+++ /dev/null
-// StdAfx.h\r
-\r
-#ifndef __STDAFX_H\r
-#define __STDAFX_H\r
-\r
-// #include "MyWindows.h"\r
-#include "NewHandler.h"\r
-\r
-#endif \r
+++ /dev/null
-// Common/Types.h\r
-\r
-#ifndef __COMMON_TYPES_H\r
-#define __COMMON_TYPES_H\r
-\r
-typedef unsigned char Byte;\r
-typedef short Int16;\r
-typedef unsigned short UInt16;\r
-typedef int Int32;\r
-typedef unsigned int UInt32;\r
-#ifdef _MSC_VER\r
-typedef __int64 Int64;\r
-typedef unsigned __int64 UInt64;\r
-#else\r
-typedef long long int Int64;\r
-typedef unsigned long long int UInt64;\r
-#endif\r
-\r
-#endif\r
+++ /dev/null
- GNU LESSER GENERAL PUBLIC LICENSE\r
- Version 2.1, February 1999\r
-\r
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.\r
- 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r
- Everyone is permitted to copy and distribute verbatim copies\r
- of this license document, but changing it is not allowed.\r
-\r
-[This is the first released version of the Lesser GPL. It also counts\r
- as the successor of the GNU Library Public License, version 2, hence\r
- the version number 2.1.]\r
-\r
- Preamble\r
-\r
- The licenses for most software are designed to take away your\r
-freedom to share and change it. By contrast, the GNU General Public\r
-Licenses are intended to guarantee your freedom to share and change\r
-free software--to make sure the software is free for all its users.\r
-\r
- This license, the Lesser General Public License, applies to some\r
-specially designated software packages--typically libraries--of the\r
-Free Software Foundation and other authors who decide to use it. You\r
-can use it too, but we suggest you first think carefully about whether\r
-this license or the ordinary General Public License is the better\r
-strategy to use in any particular case, based on the explanations below.\r
-\r
- When we speak of free software, we are referring to freedom of use,\r
-not price. Our General Public Licenses are designed to make sure that\r
-you have the freedom to distribute copies of free software (and charge\r
-for this service if you wish); that you receive source code or can get\r
-it if you want it; that you can change the software and use pieces of\r
-it in new free programs; and that you are informed that you can do\r
-these things.\r
-\r
- To protect your rights, we need to make restrictions that forbid\r
-distributors to deny you these rights or to ask you to surrender these\r
-rights. These restrictions translate to certain responsibilities for\r
-you if you distribute copies of the library or if you modify it.\r
-\r
- For example, if you distribute copies of the library, whether gratis\r
-or for a fee, you must give the recipients all the rights that we gave\r
-you. You must make sure that they, too, receive or can get the source\r
-code. If you link other code with the library, you must provide\r
-complete object files to the recipients, so that they can relink them\r
-with the library after making changes to the library and recompiling\r
-it. And you must show them these terms so they know their rights.\r
-\r
- We protect your rights with a two-step method: (1) we copyright the\r
-library, and (2) we offer you this license, which gives you legal\r
-permission to copy, distribute and/or modify the library.\r
-\r
- To protect each distributor, we want to make it very clear that\r
-there is no warranty for the free library. Also, if the library is\r
-modified by someone else and passed on, the recipients should know\r
-that what they have is not the original version, so that the original\r
-author's reputation will not be affected by problems that might be\r
-introduced by others.\r
-\f\r
- Finally, software patents pose a constant threat to the existence of\r
-any free program. We wish to make sure that a company cannot\r
-effectively restrict the users of a free program by obtaining a\r
-restrictive license from a patent holder. Therefore, we insist that\r
-any patent license obtained for a version of the library must be\r
-consistent with the full freedom of use specified in this license.\r
-\r
- Most GNU software, including some libraries, is covered by the\r
-ordinary GNU General Public License. This license, the GNU Lesser\r
-General Public License, applies to certain designated libraries, and\r
-is quite different from the ordinary General Public License. We use\r
-this license for certain libraries in order to permit linking those\r
-libraries into non-free programs.\r
-\r
- When a program is linked with a library, whether statically or using\r
-a shared library, the combination of the two is legally speaking a\r
-combined work, a derivative of the original library. The ordinary\r
-General Public License therefore permits such linking only if the\r
-entire combination fits its criteria of freedom. The Lesser General\r
-Public License permits more lax criteria for linking other code with\r
-the library.\r
-\r
- We call this license the "Lesser" General Public License because it\r
-does Less to protect the user's freedom than the ordinary General\r
-Public License. It also provides other free software developers Less\r
-of an advantage over competing non-free programs. These disadvantages\r
-are the reason we use the ordinary General Public License for many\r
-libraries. However, the Lesser license provides advantages in certain\r
-special circumstances.\r
-\r
- For example, on rare occasions, there may be a special need to\r
-encourage the widest possible use of a certain library, so that it becomes\r
-a de-facto standard. To achieve this, non-free programs must be\r
-allowed to use the library. A more frequent case is that a free\r
-library does the same job as widely used non-free libraries. In this\r
-case, there is little to gain by limiting the free library to free\r
-software only, so we use the Lesser General Public License.\r
-\r
- In other cases, permission to use a particular library in non-free\r
-programs enables a greater number of people to use a large body of\r
-free software. For example, permission to use the GNU C Library in\r
-non-free programs enables many more people to use the whole GNU\r
-operating system, as well as its variant, the GNU/Linux operating\r
-system.\r
-\r
- Although the Lesser General Public License is Less protective of the\r
-users' freedom, it does ensure that the user of a program that is\r
-linked with the Library has the freedom and the wherewithal to run\r
-that program using a modified version of the Library.\r
-\r
- The precise terms and conditions for copying, distribution and\r
-modification follow. Pay close attention to the difference between a\r
-"work based on the library" and a "work that uses the library". The\r
-former contains code derived from the library, whereas the latter must\r
-be combined with the library in order to run.\r
-\f\r
- GNU LESSER GENERAL PUBLIC LICENSE\r
- TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\r
-\r
- 0. This License Agreement applies to any software library or other\r
-program which contains a notice placed by the copyright holder or\r
-other authorized party saying it may be distributed under the terms of\r
-this Lesser General Public License (also called "this License").\r
-Each licensee is addressed as "you".\r
-\r
- A "library" means a collection of software functions and/or data\r
-prepared so as to be conveniently linked with application programs\r
-(which use some of those functions and data) to form executables.\r
-\r
- The "Library", below, refers to any such software library or work\r
-which has been distributed under these terms. A "work based on the\r
-Library" means either the Library or any derivative work under\r
-copyright law: that is to say, a work containing the Library or a\r
-portion of it, either verbatim or with modifications and/or translated\r
-straightforwardly into another language. (Hereinafter, translation is\r
-included without limitation in the term "modification".)\r
-\r
- "Source code" for a work means the preferred form of the work for\r
-making modifications to it. For a library, complete source code means\r
-all the source code for all modules it contains, plus any associated\r
-interface definition files, plus the scripts used to control compilation\r
-and installation of the library.\r
-\r
- Activities other than copying, distribution and modification are not\r
-covered by this License; they are outside its scope. The act of\r
-running a program using the Library is not restricted, and output from\r
-such a program is covered only if its contents constitute a work based\r
-on the Library (independent of the use of the Library in a tool for\r
-writing it). Whether that is true depends on what the Library does\r
-and what the program that uses the Library does.\r
- \r
- 1. You may copy and distribute verbatim copies of the Library's\r
-complete source code as you receive it, in any medium, provided that\r
-you conspicuously and appropriately publish on each copy an\r
-appropriate copyright notice and disclaimer of warranty; keep intact\r
-all the notices that refer to this License and to the absence of any\r
-warranty; and distribute a copy of this License along with the\r
-Library.\r
-\r
- You may charge a fee for the physical act of transferring a copy,\r
-and you may at your option offer warranty protection in exchange for a\r
-fee.\r
-\f\r
- 2. You may modify your copy or copies of the Library or any portion\r
-of it, thus forming a work based on the Library, and copy and\r
-distribute such modifications or work under the terms of Section 1\r
-above, provided that you also meet all of these conditions:\r
-\r
- a) The modified work must itself be a software library.\r
-\r
- b) You must cause the files modified to carry prominent notices\r
- stating that you changed the files and the date of any change.\r
-\r
- c) You must cause the whole of the work to be licensed at no\r
- charge to all third parties under the terms of this License.\r
-\r
- d) If a facility in the modified Library refers to a function or a\r
- table of data to be supplied by an application program that uses\r
- the facility, other than as an argument passed when the facility\r
- is invoked, then you must make a good faith effort to ensure that,\r
- in the event an application does not supply such function or\r
- table, the facility still operates, and performs whatever part of\r
- its purpose remains meaningful.\r
-\r
- (For example, a function in a library to compute square roots has\r
- a purpose that is entirely well-defined independent of the\r
- application. Therefore, Subsection 2d requires that any\r
- application-supplied function or table used by this function must\r
- be optional: if the application does not supply it, the square\r
- root function must still compute square roots.)\r
-\r
-These requirements apply to the modified work as a whole. If\r
-identifiable sections of that work are not derived from the Library,\r
-and can be reasonably considered independent and separate works in\r
-themselves, then this License, and its terms, do not apply to those\r
-sections when you distribute them as separate works. But when you\r
-distribute the same sections as part of a whole which is a work based\r
-on the Library, the distribution of the whole must be on the terms of\r
-this License, whose permissions for other licensees extend to the\r
-entire whole, and thus to each and every part regardless of who wrote\r
-it.\r
-\r
-Thus, it is not the intent of this section to claim rights or contest\r
-your rights to work written entirely by you; rather, the intent is to\r
-exercise the right to control the distribution of derivative or\r
-collective works based on the Library.\r
-\r
-In addition, mere aggregation of another work not based on the Library\r
-with the Library (or with a work based on the Library) on a volume of\r
-a storage or distribution medium does not bring the other work under\r
-the scope of this License.\r
-\r
- 3. You may opt to apply the terms of the ordinary GNU General Public\r
-License instead of this License to a given copy of the Library. To do\r
-this, you must alter all the notices that refer to this License, so\r
-that they refer to the ordinary GNU General Public License, version 2,\r
-instead of to this License. (If a newer version than version 2 of the\r
-ordinary GNU General Public License has appeared, then you can specify\r
-that version instead if you wish.) Do not make any other change in\r
-these notices.\r
-\f\r
- Once this change is made in a given copy, it is irreversible for\r
-that copy, so the ordinary GNU General Public License applies to all\r
-subsequent copies and derivative works made from that copy.\r
-\r
- This option is useful when you wish to copy part of the code of\r
-the Library into a program that is not a library.\r
-\r
- 4. You may copy and distribute the Library (or a portion or\r
-derivative of it, under Section 2) in object code or executable form\r
-under the terms of Sections 1 and 2 above provided that you accompany\r
-it with the complete corresponding machine-readable source code, which\r
-must be distributed under the terms of Sections 1 and 2 above on a\r
-medium customarily used for software interchange.\r
-\r
- If distribution of object code is made by offering access to copy\r
-from a designated place, then offering equivalent access to copy the\r
-source code from the same place satisfies the requirement to\r
-distribute the source code, even though third parties are not\r
-compelled to copy the source along with the object code.\r
-\r
- 5. A program that contains no derivative of any portion of the\r
-Library, but is designed to work with the Library by being compiled or\r
-linked with it, is called a "work that uses the Library". Such a\r
-work, in isolation, is not a derivative work of the Library, and\r
-therefore falls outside the scope of this License.\r
-\r
- However, linking a "work that uses the Library" with the Library\r
-creates an executable that is a derivative of the Library (because it\r
-contains portions of the Library), rather than a "work that uses the\r
-library". The executable is therefore covered by this License.\r
-Section 6 states terms for distribution of such executables.\r
-\r
- When a "work that uses the Library" uses material from a header file\r
-that is part of the Library, the object code for the work may be a\r
-derivative work of the Library even though the source code is not.\r
-Whether this is true is especially significant if the work can be\r
-linked without the Library, or if the work is itself a library. The\r
-threshold for this to be true is not precisely defined by law.\r
-\r
- If such an object file uses only numerical parameters, data\r
-structure layouts and accessors, and small macros and small inline\r
-functions (ten lines or less in length), then the use of the object\r
-file is unrestricted, regardless of whether it is legally a derivative\r
-work. (Executables containing this object code plus portions of the\r
-Library will still fall under Section 6.)\r
-\r
- Otherwise, if the work is a derivative of the Library, you may\r
-distribute the object code for the work under the terms of Section 6.\r
-Any executables containing that work also fall under Section 6,\r
-whether or not they are linked directly with the Library itself.\r
-\f\r
- 6. As an exception to the Sections above, you may also combine or\r
-link a "work that uses the Library" with the Library to produce a\r
-work containing portions of the Library, and distribute that work\r
-under terms of your choice, provided that the terms permit\r
-modification of the work for the customer's own use and reverse\r
-engineering for debugging such modifications.\r
-\r
- You must give prominent notice with each copy of the work that the\r
-Library is used in it and that the Library and its use are covered by\r
-this License. You must supply a copy of this License. If the work\r
-during execution displays copyright notices, you must include the\r
-copyright notice for the Library among them, as well as a reference\r
-directing the user to the copy of this License. Also, you must do one\r
-of these things:\r
-\r
- a) Accompany the work with the complete corresponding\r
- machine-readable source code for the Library including whatever\r
- changes were used in the work (which must be distributed under\r
- Sections 1 and 2 above); and, if the work is an executable linked\r
- with the Library, with the complete machine-readable "work that\r
- uses the Library", as object code and/or source code, so that the\r
- user can modify the Library and then relink to produce a modified\r
- executable containing the modified Library. (It is understood\r
- that the user who changes the contents of definitions files in the\r
- Library will not necessarily be able to recompile the application\r
- to use the modified definitions.)\r
-\r
- b) Use a suitable shared library mechanism for linking with the\r
- Library. A suitable mechanism is one that (1) uses at run time a\r
- copy of the library already present on the user's computer system,\r
- rather than copying library functions into the executable, and (2)\r
- will operate properly with a modified version of the library, if\r
- the user installs one, as long as the modified version is\r
- interface-compatible with the version that the work was made with.\r
-\r
- c) Accompany the work with a written offer, valid for at\r
- least three years, to give the same user the materials\r
- specified in Subsection 6a, above, for a charge no more\r
- than the cost of performing this distribution.\r
-\r
- d) If distribution of the work is made by offering access to copy\r
- from a designated place, offer equivalent access to copy the above\r
- specified materials from the same place.\r
-\r
- e) Verify that the user has already received a copy of these\r
- materials or that you have already sent this user a copy.\r
-\r
- For an executable, the required form of the "work that uses the\r
-Library" must include any data and utility programs needed for\r
-reproducing the executable from it. However, as a special exception,\r
-the materials to be distributed need not include anything that is\r
-normally distributed (in either source or binary form) with the major\r
-components (compiler, kernel, and so on) of the operating system on\r
-which the executable runs, unless that component itself accompanies\r
-the executable.\r
-\r
- It may happen that this requirement contradicts the license\r
-restrictions of other proprietary libraries that do not normally\r
-accompany the operating system. Such a contradiction means you cannot\r
-use both them and the Library together in an executable that you\r
-distribute.\r
-\f\r
- 7. You may place library facilities that are a work based on the\r
-Library side-by-side in a single library together with other library\r
-facilities not covered by this License, and distribute such a combined\r
-library, provided that the separate distribution of the work based on\r
-the Library and of the other library facilities is otherwise\r
-permitted, and provided that you do these two things:\r
-\r
- a) Accompany the combined library with a copy of the same work\r
- based on the Library, uncombined with any other library\r
- facilities. This must be distributed under the terms of the\r
- Sections above.\r
-\r
- b) Give prominent notice with the combined library of the fact\r
- that part of it is a work based on the Library, and explaining\r
- where to find the accompanying uncombined form of the same work.\r
-\r
- 8. You may not copy, modify, sublicense, link with, or distribute\r
-the Library except as expressly provided under this License. Any\r
-attempt otherwise to copy, modify, sublicense, link with, or\r
-distribute the Library is void, and will automatically terminate your\r
-rights under this License. However, parties who have received copies,\r
-or rights, from you under this License will not have their licenses\r
-terminated so long as such parties remain in full compliance.\r
-\r
- 9. You are not required to accept this License, since you have not\r
-signed it. However, nothing else grants you permission to modify or\r
-distribute the Library or its derivative works. These actions are\r
-prohibited by law if you do not accept this License. Therefore, by\r
-modifying or distributing the Library (or any work based on the\r
-Library), you indicate your acceptance of this License to do so, and\r
-all its terms and conditions for copying, distributing or modifying\r
-the Library or works based on it.\r
-\r
- 10. Each time you redistribute the Library (or any work based on the\r
-Library), the recipient automatically receives a license from the\r
-original licensor to copy, distribute, link with or modify the Library\r
-subject to these terms and conditions. You may not impose any further\r
-restrictions on the recipients' exercise of the rights granted herein.\r
-You are not responsible for enforcing compliance by third parties with\r
-this License.\r
-\f\r
- 11. If, as a consequence of a court judgment or allegation of patent\r
-infringement or for any other reason (not limited to patent issues),\r
-conditions are imposed on you (whether by court order, agreement or\r
-otherwise) that contradict the conditions of this License, they do not\r
-excuse you from the conditions of this License. If you cannot\r
-distribute so as to satisfy simultaneously your obligations under this\r
-License and any other pertinent obligations, then as a consequence you\r
-may not distribute the Library at all. For example, if a patent\r
-license would not permit royalty-free redistribution of the Library by\r
-all those who receive copies directly or indirectly through you, then\r
-the only way you could satisfy both it and this License would be to\r
-refrain entirely from distribution of the Library.\r
-\r
-If any portion of this section is held invalid or unenforceable under any\r
-particular circumstance, the balance of the section is intended to apply,\r
-and the section as a whole is intended to apply in other circumstances.\r
-\r
-It is not the purpose of this section to induce you to infringe any\r
-patents or other property right claims or to contest validity of any\r
-such claims; this section has the sole purpose of protecting the\r
-integrity of the free software distribution system which is\r
-implemented by public license practices. Many people have made\r
-generous contributions to the wide range of software distributed\r
-through that system in reliance on consistent application of that\r
-system; it is up to the author/donor to decide if he or she is willing\r
-to distribute software through any other system and a licensee cannot\r
-impose that choice.\r
-\r
-This section is intended to make thoroughly clear what is believed to\r
-be a consequence of the rest of this License.\r
-\r
- 12. If the distribution and/or use of the Library is restricted in\r
-certain countries either by patents or by copyrighted interfaces, the\r
-original copyright holder who places the Library under this License may add\r
-an explicit geographical distribution limitation excluding those countries,\r
-so that distribution is permitted only in or among countries not thus\r
-excluded. In such case, this License incorporates the limitation as if\r
-written in the body of this License.\r
-\r
- 13. The Free Software Foundation may publish revised and/or new\r
-versions of the Lesser General Public License from time to time.\r
-Such new versions will be similar in spirit to the present version,\r
-but may differ in detail to address new problems or concerns.\r
-\r
-Each version is given a distinguishing version number. If the Library\r
-specifies a version number of this License which applies to it and\r
-"any later version", you have the option of following the terms and\r
-conditions either of that version or of any later version published by\r
-the Free Software Foundation. If the Library does not specify a\r
-license version number, you may choose any version ever published by\r
-the Free Software Foundation.\r
-\f\r
- 14. If you wish to incorporate parts of the Library into other free\r
-programs whose distribution conditions are incompatible with these,\r
-write to the author to ask for permission. For software which is\r
-copyrighted by the Free Software Foundation, write to the Free\r
-Software Foundation; we sometimes make exceptions for this. Our\r
-decision will be guided by the two goals of preserving the free status\r
-of all derivatives of our free software and of promoting the sharing\r
-and reuse of software generally.\r
-\r
- NO WARRANTY\r
-\r
- 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO\r
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.\r
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR\r
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY\r
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE\r
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
-PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE\r
-LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME\r
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\r
-\r
- 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN\r
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY\r
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU\r
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR\r
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE\r
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING\r
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A\r
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF\r
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH\r
-DAMAGES.\r
-\r
- END OF TERMS AND CONDITIONS\r
-\f\r
- How to Apply These Terms to Your New Libraries\r
-\r
- If you develop a new library, and you want it to be of the greatest\r
-possible use to the public, we recommend making it free software that\r
-everyone can redistribute and change. You can do so by permitting\r
-redistribution under these terms (or, alternatively, under the terms of the\r
-ordinary General Public License).\r
-\r
- To apply these terms, attach the following notices to the library. It is\r
-safest to attach them to the start of each source file to most effectively\r
-convey the exclusion of warranty; and each file should have at least the\r
-"copyright" line and a pointer to where the full notice is found.\r
-\r
- <one line to give the library's name and a brief idea of what it does.>\r
- Copyright (C) <year> <name of author>\r
-\r
- This library is free software; you can redistribute it and/or\r
- modify it under the terms of the GNU Lesser General Public\r
- License as published by the Free Software Foundation; either\r
- version 2.1 of the License, or (at your option) any later version.\r
-\r
- This library is distributed in the hope that it will be useful,\r
- but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r
- Lesser General Public License for more details.\r
-\r
- You should have received a copy of the GNU Lesser General Public\r
- License along with this library; if not, write to the Free Software\r
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r
-\r
-Also add information on how to contact you by electronic and paper mail.\r
-\r
-You should also get your employer (if you work as a programmer) or your\r
-school, if any, to sign a "copyright disclaimer" for the library, if\r
-necessary. Here is a sample; alter the names:\r
-\r
- Yoyodyne, Inc., hereby disclaims all copyright interest in the\r
- library `Frob' (a library for tweaking knobs) written by James Random Hacker.\r
-\r
- <signature of Ty Coon>, 1 April 1990\r
- Ty Coon, President of Vice\r
-\r
-That's all there is to it!\r
-\r
-\r
+++ /dev/null
-The contents of this directory are extracted from
-the official LZMA SDK, version lzma442.tar.bz2 ,
-for the use in mkcromfs.
+++ /dev/null
-##
-## This file is part of the coreboot project.
-##
-## Copyright (C) 2007 coresystems GmbH
-##
-## This program is free software; you can redistribute it and/or modify
-## it under the terms of the GNU General Public License as published by
-## the Free Software Foundation; either version 2 of the License, or
-## (at your option) any later version.
-##
-## This program 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 General Public License for more details.
-##
-## You should have received a copy of the GNU General Public License
-## along with this program; if not, write to the Free Software
-## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-##
-
-LZMA_OBJ := lzma/LZMAEncoder.o lzma/LZInWindow.o
-LZMA_OBJ += lzma/RangeCoderBit.o lzma/StreamUtils.o
-LZMA_OBJ += lzma/OutBuffer.o lzma/Alloc.o
-LZMA_OBJ += lzma/CRC.o
-LZMA_OBJ += lzma/lzma-compress.o
-
-$(tobj)/lzma/lzma-compress.o: $(tsrc)/lzma/minilzma.cc
- $(CXX) $(CFLAGS) -o $@ -c -DCOMPACT $<
-
-$(tobj)/lzma/%.o: $(tsrc)/lzma/C/7zip/Compress/LZMA/%.cpp
- $(CXX) $(CFLAGS) -o $@ -c $<
-
-$(tobj)/lzma/%.o: $(tsrc)/lzma/C/7zip/Compress/LZ/%.cpp
- $(CXX) $(CFLAGS) -o $@ -c $<
-
-$(tobj)/lzma/%.o: $(tsrc)/lzma/C/7zip/Compress/RangeCoder/%.cpp
- $(CXX) $(CFLAGS) -o $@ -c $<
-
-$(tobj)/lzma/%.o: $(tsrc)/lzma/C/7zip/Decompress/%.cpp
- $(CXX) $(CFLAGS) -o $@ -c $<
-
-$(tobj)/lzma/%.o: $(tsrc)/lzma/C/7zip/Common/%.cpp
- $(CXX) $(CFLAGS) -o $@ -c $<
-
-$(tobj)/lzma/%.o: $(tsrc)/lzma/C/Common/%.cpp
- $(CXX) $(CFLAGS) -o $@ -c $<
-
-$(tobj)/lzma/%.o: $(tsrc)/lzma/%.cc
- $(CXX) $(CFLAGS) -o $@ -c $<
-
+++ /dev/null
-/*
- * minimal lzma implementation
- *
- * Copyright (C) 2002 Eric Biederman
- * Copyright (C) 2005 Joel Yliluoma
- * Copyright (C) 2007 coresystems GmbH
- * (Adapted by Stefan Reinauer <stepan@coresystems.de> for coresystems GmbH)
- * Copyright (C) 2007 Patrick Georgi <patrick@georgi-clan.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#include "C/Common/MyInitGuid.h"
-#include "C/7zip/Compress/LZMA/LZMAEncoder.h"
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <errno.h>
-#include <cstring>
-#include <cstdio>
-#include <cstdlib>
-#include <cctype>
-
-#include <vector>
-#include <algorithm>
-#include <stdint.h>
-
-const std::vector<unsigned char> LZMACompress
- (const std::vector<unsigned char>& buf);
-
-const std::vector<unsigned char> LZMADeCompress
- (const std::vector<unsigned char>& buf);
-
-static inline uint16_t R16(const void* p)
-{
- const unsigned char* data = (const unsigned char*)p;
- return (data[0] << 0) | (data[1] << 8);
-}
-static inline uint32_t R32(const void* p)
-{
- const unsigned char* data = (const unsigned char*)p;
- return R16(data) | (R16(data+2) << 16);
-}
-
-#define L (uint64_t)
-
-static inline uint64_t R64(const void* p)
-{
- const unsigned char* data = (const unsigned char*)p;
- return (L R32(data)) | ((L R32(data+4)) << 32);
-}
-
-#undef L
-
-static UInt32 SelectDictionarySizeFor(unsigned datasize)
-{
- #if 1
- return datasize;
- #else
-#ifdef __GNUC__
- /* gnu c can optimize this switch statement into a fast binary
- * search, but it cannot do so for the list of the if statements.
- */
- switch(datasize)
- {
- case 0 ... 512 : return 512;
- case 513 ... 1024: return 2048;
- case 1025 ... 4096: return 8192;
- case 4097 ... 16384: return 32768;
- case 16385 ... 65536: return 528288;
- case 65537 ... 528288: return 1048576*4;
- case 528289 ... 786432: return 1048576*16;
- default: return 1048576*32;
- }
-#else
- if(datasize <= 512) return 512;
- if(datasize <= 1024) return 1024;
- if(datasize <= 4096) return 4096;
- if(datasize <= 16384) return 32768;
- if(datasize <= 65536) return 528288;
- if(datasize <= 528288) return 1048576*4;
- if(datasize <= 786432) reutrn 1048576*16;
- return 32*1048576;
-#endif
- #endif
-}
-
-
-class CInStreamRam: public ISequentialInStream, public CMyUnknownImp
-{
- const std::vector<unsigned char>& input;
- size_t Pos;
-public:
- MY_UNKNOWN_IMP
-
- CInStreamRam(const std::vector<unsigned char>& buf) : input(buf), Pos(0)
- {
- }
- virtual ~CInStreamRam() {}
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-};
-
-STDMETHODIMP CInStreamRam::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- UInt32 remain = input.size() - Pos;
- if (size > remain) size = remain;
-
- std::memcpy(data, &input[Pos], size);
- Pos += size;
-
- if(processedSize != NULL) *processedSize = size;
-
- return S_OK;
-}
-
-class COutStreamRam: public ISequentialOutStream, public CMyUnknownImp
-{
- std::vector<Byte> result;
- size_t Pos;
-public:
- MY_UNKNOWN_IMP
-
- COutStreamRam(): result(), Pos(0) { }
- virtual ~COutStreamRam() { }
-
- void Reserve(unsigned n) { result.reserve(n); }
- const std::vector<Byte>& Get() const { return result; }
-
- HRESULT WriteByte(Byte b)
- {
- if(Pos >= result.size()) result.resize(Pos+1);
- result[Pos++] = b;
- return S_OK;
- }
-
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-};
-
-STDMETHODIMP COutStreamRam::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- if(Pos+size > result.size()) result.resize(Pos+size);
-
- std::memcpy(&result[Pos], data, size);
- if(processedSize != NULL) *processedSize = size;
- Pos += size;
- return S_OK;
-}
-
-const std::vector<unsigned char> LZMACompress(const std::vector<unsigned char>& buf)
-{
- if(buf.empty()) return buf;
-
- const UInt32 dictionarysize = SelectDictionarySizeFor(buf.size());
-
- NCompress::NLZMA::CEncoder *encoderSpec = new NCompress::NLZMA::CEncoder;
- CMyComPtr<ICompressCoder> encoder = encoderSpec;
- const PROPID propIDs[] =
- {
- NCoderPropID::kAlgorithm,
- NCoderPropID::kDictionarySize,
- NCoderPropID::kNumFastBytes,
- };
- const unsigned kNumProps = sizeof(propIDs) / sizeof(propIDs[0]);
- PROPVARIANT properties[kNumProps];
- properties[0].vt = VT_UI4; properties[0].ulVal = (UInt32)2;
- properties[1].vt = VT_UI4; properties[1].ulVal = (UInt32)dictionarysize;
- properties[2].vt = VT_UI4; properties[2].ulVal = (UInt32)64;
-
- if (encoderSpec->SetCoderProperties(propIDs, properties, kNumProps) != S_OK)
- {
- Error:
- return std::vector<unsigned char> ();
- }
-
- COutStreamRam *const outStreamSpec = new COutStreamRam;
- CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
- CInStreamRam *const inStreamSpec = new CInStreamRam(buf);
- CMyComPtr<ISequentialInStream> inStream = inStreamSpec;
-
- outStreamSpec->Reserve(buf.size());
-
- if (encoderSpec->WriteCoderProperties(outStream) != S_OK) goto Error;
-
- for (unsigned i = 0; i < 8; i++)
- {
- UInt64 t = (UInt64)buf.size();
- outStreamSpec->WriteByte((Byte)((t) >> (8 * i)));
- }
-
- HRESULT lzmaResult = encoder->Code(inStream, outStream, 0, 0, 0);
- if (lzmaResult != S_OK) goto Error;
-
- return outStreamSpec->Get();
-}
-
-#undef RC_NORMALIZE
-
-#include "C/7zip/Decompress/LzmaDecode.h"
-#include "C/7zip/Decompress/LzmaDecode.c"
-
-const std::vector<unsigned char> LZMADeCompress
- (const std::vector<unsigned char>& buf)
-{
- if(buf.size() <= 5+8) return std::vector<unsigned char> ();
-
- uint_least64_t out_sizemax = R64(&buf[5]);
-
- std::vector<unsigned char> result(out_sizemax);
-
- CLzmaDecoderState state;
- LzmaDecodeProperties(&state.Properties, &buf[0], LZMA_PROPERTIES_SIZE);
- state.Probs = new CProb[LzmaGetNumProbs(&state.Properties)];
-
- SizeT in_done;
- SizeT out_done;
- LzmaDecode(&state, &buf[13], buf.size()-13, &in_done,
- &result[0], result.size(), &out_done);
-
- delete[] state.Probs;
-
- result.resize(out_done);
- return result;
-}
-
-#ifndef COMPACT
-int main(int argc, char *argv[])
-{
- char *s;
- FILE *f, *infile, *outfile;
- int c;
-
- if (argc != 4) {
- std::fprintf(stderr, "'lzma e file1 file2' encodes file1 into file2.\n"
- "'lzma d file2 file1' decodes file2 into file1.\n");
-
- return EXIT_FAILURE;
- }
- if (argc == 4) {
- if ((s = argv[1], s[1] || strpbrk(s, "DEde") == NULL)
- || (s = argv[2], (infile = fopen(s, "rb")) == NULL)
- || (s = argv[3], (outfile = fopen(s, "wb")) == NULL)) {
- std::fprintf(stderr, "??? %s\n", s);
- return EXIT_FAILURE;
- }
- }
-
- struct stat fs;
- int si;
- if (fstat(fileno(infile), &fs)) {
- std::perror(strerror(errno));
- return EXIT_FAILURE;
- }
- si=fs.st_size;
-
- char *Buf=(char *)malloc(si);
- fread(Buf,si, 1, infile);
-
- std::vector<unsigned char> result;
- if (toupper(*argv[1]) == 'E')
- result = LZMACompress(std::vector<unsigned char>(Buf,Buf+si));
- else
- result = LZMADeCompress(std::vector<unsigned char>(Buf,Buf+si));
-
- fwrite(&result[0], result.size(), 1, outfile);
- fclose(infile);
- fclose(outfile);
- return EXIT_SUCCESS;
-}
-#else
-extern "C" {
-
-/**
- * Compress a buffer with lzma
- * Don't copy the result back if it is too large.
- * @param in a pointer to the buffer
- * @param in_len the length in bytes
- * @param out a pointer to a buffer of at least size in_len
- * @param out_len a pointer to the compressed length of in
- */
-
-void do_lzma_compress(char *in, int in_len, char *out, int *out_len) {
- std::vector<unsigned char> result;
- result = LZMACompress(std::vector<unsigned char>(in, in + in_len));
- *out_len = result.size();
- if (*out_len < in_len)
- std::memcpy(out, &result[0], *out_len);
-}
-
-void do_lzma_uncompress(char *dst, int dst_len, char *src, int src_len) {
- std::vector<unsigned char> result;
- result = LZMADeCompress(std::vector<unsigned char>(src, src + src_len));
- if (result.size() <= dst_len)
- std::memcpy(dst, &result[0], result.size());
- else
- {
- fprintf(stderr, "Not copying %d bytes to %d-byte buffer!\n",
- result.size(), dst_len);
- exit(1);
- }
-}
-
-}
-#endif
-
+++ /dev/null
-/*
- * rom-mkpayload
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include "elf.h"
-#include <fcntl.h>
-#include <getopt.h>
-#include <sys/stat.h>
-#include <arpa/inet.h>
-
-#include "common.h"
-#include "../romfs.h"
-
-int parse_elf(unsigned char *input, unsigned char **output, int algo,
- void (*compress) (char *, int, char *, int *))
-{
- Elf32_Phdr *phdr;
- Elf32_Ehdr *ehdr;
- Elf32_Shdr *shdr;
- char *header;
- char *strtab;
- unsigned char *sptr;
- int headers;
- int segments = 1;
- int isize = 0, osize = 0;
- int doffset = 0;
- struct romfs_payload_segment *segs;
- int i;
-
- ehdr = (Elf32_Ehdr *) input;
- headers = ehdr->e_phnum;
- header = (char *)ehdr;
-
- phdr = (Elf32_Phdr *) & (header[ehdr->e_phoff]);
- shdr = (Elf32_Shdr *) & (header[ehdr->e_shoff]);
-
- strtab = &header[shdr[ehdr->e_shstrndx].sh_offset];
-
- /* Count the number of headers - look for the .notes.pinfo
- * section */
-
- for (i = 0; i < ehdr->e_shnum; i++) {
- char *name;
-
- if (i == ehdr->e_shstrndx)
- continue;
-
- if (shdr[i].sh_size == 0)
- continue;
-
- name = (char *)(strtab + shdr[i].sh_name);
-
- if (!strcmp(name, ".note.pinfo"))
- segments++;
- }
-
- /* Now, regular headers - we only care about PT_LOAD headers,
- * because thats what we're actually going to load
- */
-
- for (i = 0; i < headers; i++) {
- if (phdr[i].p_type != PT_LOAD)
- continue;
-
- /* Empty segments are never interesting */
- if (phdr[i].p_memsz == 0)
- continue;
-
- isize += phdr[i].p_filesz;
-
- segments++;
- }
-
- /* Allocate a block of memory to store the data in */
-
- sptr =
- calloc((segments * sizeof(struct romfs_payload_segment)) + isize,
- 1);
- doffset = (segments * sizeof(struct romfs_payload_segment));
-
- if (sptr == NULL)
- goto err;
-
- segs = (struct romfs_payload_segment *)sptr;
- segments = 0;
-
- for (i = 0; i < ehdr->e_shnum; i++) {
- char *name;
-
- if (i == ehdr->e_shstrndx)
- continue;
-
- if (shdr[i].sh_size == 0)
- continue;
-
- name = (char *)(strtab + shdr[i].sh_name);
-
- if (!strcmp(name, ".note.pinfo")) {
- segs[segments].type = PAYLOAD_SEGMENT_PARAMS;
- segs[segments].load_addr = 0;
- segs[segments].len = (unsigned int)shdr[i].sh_size;
- segs[segments].offset = doffset;
-
- memcpy((unsigned long *)(sptr + doffset),
- &header[shdr[i].sh_offset], shdr[i].sh_size);
-
- doffset += segs[segments].len;
- osize += segs[segments].len;
-
- segments++;
- }
- }
-
- for (i = 0; i < headers; i++) {
- if (phdr[i].p_type != PT_LOAD)
- continue;
-
- if (phdr[i].p_memsz == 0)
- continue;
-
- if (phdr[i].p_filesz == 0) {
- segs[segments].type = PAYLOAD_SEGMENT_BSS;
- segs[segments].load_addr =
- (unsigned long long)htonl(phdr[i].p_paddr);
- segs[segments].mem_len = (unsigned int)htonl(phdr[i].p_memsz);
- segs[segments].offset = htonl(doffset);
-
- segments++;
- continue;
- }
-
- segs[segments].type = PAYLOAD_SEGMENT_DATA;
- segs[segments].load_addr = (unsigned int)htonl(phdr[i].p_paddr);
- segs[segments].mem_len = (unsigned int)htonl(phdr[i].p_memsz);
- segs[segments].compression = htonl(algo);
- segs[segments].offset = htonl(doffset);
-
- int len;
- compress((char *)&header[phdr[i].p_offset],
- phdr[i].p_filesz,
- (char *)(sptr + doffset), &len);
- segs[segments].len = htonl(len);
-
- /* If the compressed section is larger, then use the
- original stuff */
-
- if ((unsigned int)len > phdr[i].p_filesz) {
- segs[segments].compression = 0;
- segs[segments].len = htonl(phdr[i].p_filesz);
-
- memcpy((char *)(sptr + doffset),
- &header[phdr[i].p_offset], phdr[i].p_filesz);
- }
-
- doffset += ntohl(segs[segments].len);
- osize += ntohl(segs[segments].len);
-
- segments++;
- }
-
- segs[segments].type = PAYLOAD_SEGMENT_ENTRY;
- segs[segments++].load_addr = (unsigned long long)htonl(ehdr->e_entry);
-
- *output = sptr;
-
- return (segments * sizeof(struct romfs_payload_segment)) + osize;
-
-err:
- return -1;
-}
-
-int main(int argc, char **argv)
-{
- void (*compress) (char *, int, char *, int *);
- int algo;
-
- char *output = NULL;
- char *input = NULL;
-
- unsigned char *buffer, *obuffer;
- int size, osize;
-
- while (1) {
- int option_index;
- static struct option longopt[] = {
- {"output", 1, 0, 'o'},
- {"lzma", 0, 0, 'l'},
- {"nocompress", 0, 0, 'n'},
- };
-
- signed char ch = getopt_long(argc, argv, "o:ln",
- longopt, &option_index);
-
- if (ch == -1)
- break;
-
- switch (ch) {
- case 'o':
- output = optarg;
- break;
- case 'l':
- algo = ROMFS_COMPRESS_LZMA;
- break;
- case 'n':
- algo = ROMFS_COMPRESS_NONE;
- break;
- default:
- //usage();
- return -1;
- }
- }
-
- if (optind < argc)
- input = argv[optind];
-
- if (input == NULL || !strcmp(input, "-"))
- buffer = file_read_to_buffer(STDIN_FILENO, &size);
- else {
- printf("Reading from %s\n", input);
- buffer = file_read(input, &size);
- }
-
- if (!iself(buffer)) {
- fprintf(stderr, "E: This does not appear to be an ELF file\n");
- return -1;
- }
-
- switch (algo) {
- case ROMFS_COMPRESS_NONE:
- compress = none_compress;
- break;
- case ROMFS_COMPRESS_LZMA:
- compress = lzma_compress;
- break;
- }
-
- osize = parse_elf(buffer, &obuffer, algo, compress);
-
- if (osize == -1) {
- fprintf(stderr, "E: Error while converting the payload\n");
- return -1;
- }
-
- if (output == NULL || !strcmp(output, "-"))
- file_write_from_buffer(STDOUT_FILENO, obuffer, osize);
- else
- file_write(output, obuffer, osize);
-
- return 0;
-}
+++ /dev/null
-/*
- * rom-mkstage
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include "elf.h"
-#include <fcntl.h>
-#include <getopt.h>
-#include <sys/stat.h>
-
-#include "common.h"
-#include "../romfs.h"
-
-int parse_elf(unsigned char *input, unsigned char **output,
- int mode, void (*compress) (char *, int, char *, int *))
-{
- Elf32_Phdr *phdr;
- Elf32_Ehdr *ehdr = (Elf32_Ehdr *) input;
- Elf32_Shdr *shdr;
- char *header, *buffer;
- unsigned char *out;
-
- int headers;
- int i;
- struct romfs_stage *stage;
- unsigned int data_start, data_end, mem_end;
-
- headers = ehdr->e_phnum;
- header = (char *)ehdr;
-
- phdr = (Elf32_Phdr *) & (header[ehdr->e_phoff]);
- shdr = (Elf32_Shdr *) & (header[ehdr->e_shoff]);
-
- /* Now, regular headers - we only care about PT_LOAD headers,
- * because thats what we're actually going to load
- */
-
- data_start = 0xFFFFFFFF;
- data_end = 0;
- mem_end = 0;
-
- for (i = 0; i < headers; i++) {
- unsigned int start, mend, rend;
-
- if (phdr[i].p_type != PT_LOAD)
- continue;
-
- /* Empty segments are never interesting */
- if (phdr[i].p_memsz == 0)
- continue;
-
- /* BSS */
-
- start = phdr[i].p_paddr;
-
- mend = start + phdr[i].p_memsz;
- rend = start + phdr[i].p_filesz;
-
- if (start < data_start)
- data_start = start;
-
- if (rend > data_end)
- data_end = rend;
-
- if (mend > mem_end)
- mem_end = mend;
- }
-
- /* allocate an intermediate buffer for the data */
- buffer = calloc(data_end - data_start, 1);
-
- if (buffer == NULL) {
- fprintf(stderr, "E: Unable to allocate memory: %m\n");
- return -1;
- }
-
- /* Copy the file data into the buffer */
-
- for (i = 0; i < headers; i++) {
-
- if (phdr[i].p_type != PT_LOAD)
- continue;
-
- if (phdr[i].p_memsz == 0)
- continue;
-
- memcpy(buffer + (phdr[i].p_paddr - data_start),
- &header[phdr[i].p_offset], phdr[i].p_filesz);
- }
-
- /* Now make the output buffer */
- out = calloc(sizeof(struct romfs_stage) + data_end - data_start, 1);
-
- if (out == NULL) {
- fprintf(stderr, "E: Unable to allocate memory: %m\n");
- return -1;
- }
-
- stage = (struct romfs_stage *)out;
-
- stage->load = data_start;
- stage->memlen = mem_end - data_start;
- stage->compression = mode;
- stage->entry = ehdr->e_entry;
-
- compress(buffer, data_end - data_start,
- (char *)(out + sizeof(struct romfs_stage)),
- (int *)&stage->len);
-
- *output = out;
-
- return sizeof(struct romfs_stage) + stage->len;
-}
-
-int main(int argc, char **argv)
-{
- void (*compress) (char *, int, char *, int *);
- int algo = ROMFS_COMPRESS_LZMA;
-
- char *output = NULL;
- char *input = NULL;
-
- unsigned char *buffer, *obuffer;
- int size, osize;
-
- while (1) {
- int option_index;
- static struct option longopt[] = {
- {"output", 1, 0, 'o'},
- {"lzma", 0, 0, 'l'},
- {"nocompress", 0, 0, 'n'},
- };
-
- signed char ch = getopt_long(argc, argv, "o:ln",
- longopt, &option_index);
-
- if (ch == -1)
- break;
-
- switch (ch) {
- case 'o':
- output = optarg;
- break;
- case 'l':
- algo = ROMFS_COMPRESS_LZMA;
- break;
- case 'n':
- algo = ROMFS_COMPRESS_NONE;
- break;
- default:
- //usage();
- return -1;
- }
- }
-
- if (optind < argc)
- input = argv[optind];
-
- if (input == NULL || !strcmp(input, "-"))
- buffer = file_read_to_buffer(STDIN_FILENO, &size);
- else
- buffer = file_read(input, &size);
-
- if (!iself(buffer)) {
- fprintf(stderr, "E: The incoming file is not an ELF\n");
- return -1;
- }
-
- switch (algo) {
- case ROMFS_COMPRESS_NONE:
- compress = none_compress;
- break;
- case ROMFS_COMPRESS_LZMA:
- compress = lzma_compress;
- break;
- }
-
- osize = parse_elf(buffer, &obuffer, algo, compress);
-
- if (osize == -1) {
- fprintf(stderr, "E: Error while converting the ELF\n");
- return -1;
- }
-
- if (output == NULL || !strcmp(output, "-"))
- file_write_from_buffer(STDOUT_FILENO, obuffer, osize);
- else
- file_write(output, obuffer, osize);
-
- return 0;
-}
+++ /dev/null
-/*
- * romtool
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#include <string.h>
-#include "romtool.h"
-
-static const struct {
- char *type;
- unsigned int value;
- int (*detect) (const char *filename);
- int (*handler) (const char *filename, const char *name);
-} component_types[] = {
- {
-NULL, 0xFF, NULL, NULL},};
-
-int parse_type(const char *str, unsigned int *type)
-{
- int i;
- for (i = 0; component_types[i].type != NULL; i++) {
- if (!strncmp(str, component_types[i].type,
- strlen(compoent_types[i].type))) {
- *type = component_types[i].value;
- return 0;
- }
- }
-
- return -1;
-}
-
-int detect_type(const char *filename)
-{
-
- int i;
-
- for (i = 0; component_types[i].type != NULL; i++) {
- if (component_types[i].detect &&
- !component_types[i].detect(filename))
- return component_types[i].value;
-
- }
-}
-
-int handle_type(const char *filename, int type, int *ret)
-{
- /* Now send the file to the required handler */
- for (i = 0; component_types[i].type != NULL; i++) {
- if (type == component_types[i].value) {
- *ret = component_types[i].handler(config,
- argv[0], argv[1]);
- return 0;
- }
- }
-
- return -1;
-}
-
-void get_type(int type, char *buffer, int len)
-{
- for (i = 0; component_types[i].type != NULL; i++) {
- if (type == component_types[i].value) {
- strncpy(buffer, component_types[i].type, len - 1);
- buffer[len - 1] = '\0';
- return;
- }
- }
-
- snprintf(buffer, len, "%x\n", type);
-}
+++ /dev/null
-/*
- * romtool
- *
- * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- */
-
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <sys/mman.h>
-#include "romtool.h"
-
-int get_size(const char *size)
-{
- char *next;
- int val = strtoul(size, &next, 0);
-
- /* Support modifiers for the size kK and mM for kbytes and
- mbytes respectfully */
-
- if (next != NULL) {
- if (*next == 'k' || *next == 'K')
- val *= 1024;
- else if (*next == 'm' || *next == 'M')
- val *= (1024 * 1024);
- }
-
- return val;
-}
-
-int copy_from_fd(int fd, void *ptr, int size)
-{
- unsigned char *p = ptr;
-
- while (size > 0) {
- int ret = read(fd, p, size);
-
- if (ret == -1) {
- ERROR("Error while reading: %m\n");
- return -1;
- }
-
- if (ret == 0) {
- ERROR("Unexpected end of file\n");
- return -1;
- }
-
- p += ret;
- size -= ret;
- }
-
- return 0;
-}
-
-int size_and_open(const char *filename, unsigned int *size)
-{
- struct stat s;
-
- int fd = open(filename, O_RDONLY);
-
- if (fd == -1) {
- ERROR("Unable to open %s: %m\n", filename);
- return -1;
- }
-
- if (fstat(fd, &s)) {
- ERROR("Unable to stat %s: %m\n", filename);
- close(fd);
- return -1;
- }
-
- *size = s.st_size;
- return fd;
-}
-
-int map_rom(struct rom *rom, int size)
-{
- rom->ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED,
- rom->fd, 0);
-
- if (rom->ptr == MAP_FAILED) {
- ERROR("Could not map the rom: %m\n");
- rom->ptr = NULL;
- return -1;
- }
-
- return 0;
-}
-
-int open_rom(struct rom *rom, const char *filename)
-{
- struct stat s;
- unsigned long offset;
-
- if (stat(filename, &s)) {
- ERROR("Could not stat %s: %m\n", filename);
- return -1;
- }
-
- rom->fd = open(filename, O_RDWR);
-
- if (rom->fd == -1) {
- ERROR("Could not open %s: %m\n", filename);
- rom->fd = 0;
- return -1;
- }
-
- if (map_rom(rom, s.st_size))
- goto err;
-
- /* Find the master header */
-
- offset = ROM_READL(rom, s.st_size - 4);
-
- rom->header = (struct romfs_header *)
- ROM_PTR(rom, s.st_size - (0xFFFFFFFF - offset) - 1);
-
- if (ntohl(rom->header->magic) != HEADER_MAGIC) {
- ERROR("This does not appear to be a valid ROM\n");
- goto err;
- }
-
- /* Check that the alignment is correct */
- if (ntohl(rom->header->align) == 0) {
- ERROR("The alignment in the ROM is 0 - probably malformed\n");
- goto err;
- }
-
- /* Sanity check that the size matches the file size */
-
- if (ntohl(rom->header->romsize) != s.st_size) {
- ERROR("The ROM size in the header does not match the file\n");
- ERROR("ROM size is %d bytes, file size is %d bytes\n",
- ntohl(rom->header->romsize), (unsigned int)s.st_size);
- goto err;
- }
-
- rom->size = ntohl(rom->header->romsize);
- rom->fssize = rom->size - ntohl(rom->header->bootblocksize);
-
- return 0;
-
-err:
- if (rom->ptr != NULL)
- munmap(rom->ptr, s.st_size);
-
- if (rom->fd > 0)
- close(rom->fd);
-
- rom->ptr = NULL;
- rom->fd = 0;
- return -1;
-}
-
-int create_rom(struct rom *rom, const unsigned char *filename,
- int romsize, int bootblocksize, int align)
-{
- unsigned char null = '\0';
-
- if (rom->fd != 0) {
- ERROR("%s already exists - cannot create\n", filename);
- return -1;
- }
-
- /* Remember the size of the entire ROM */
- rom->size = romsize;
-
- /* The size of the archive section is everything but the bootblock */
- rom->fssize = romsize - bootblocksize;
-
- /* Open the file descriptor */
-
- rom->fd = open((char *)filename, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
-
- if (rom->fd == -1) {
- ERROR("Could not create %s: %m\n", filename);
- return -1;
- }
-
- /* Size the new file appropriately */
- lseek(rom->fd, romsize - 1, SEEK_SET);
- write(rom->fd, &null, 1);
-
- if (map_rom(rom, romsize)) {
- close(rom->fd);
- return -1;
- }
-
- /* Clear the reset vector */
- memset(rom->ptr + rom->size - 16, 0, 16);
-
- ROM_WRITEL(rom, rom->size - 4,
- 0xFFFFFFF0 - sizeof(struct romfs_header));
-
- /* This is a pointer to the header for easy access */
- rom->header = (struct romfs_header *)
- ROM_PTR(rom, rom->size - 16 - sizeof(struct romfs_header));
-
- rom->header->magic = htonl(HEADER_MAGIC);
- rom->header->romsize = htonl(romsize);
- rom->header->bootblocksize = htonl(bootblocksize);
- rom->header->align = htonl(align);
- rom->header->offset = htonl(0);
-
- return 0;
-}
-
-int add_bootblock(struct rom *rom, const char *filename)
-{
- unsigned int size;
- //unsigned int offset;
- int fd = size_and_open(filename, &size);
- int ret;
- struct romfs_header tmp;
-
- if (fd == -1)
- return -1;
-
- if (size > ntohl(rom->header->bootblocksize)) {
- ERROR("The bootblock size is not correct (%d vs %d)\n",
- size, ntohl(rom->header->bootblocksize));
- return -1;
- }
-
- /* Copy the current header into a temporary buffer */
- memcpy(&tmp, rom->header, sizeof(struct romfs_header));
-
- /* Copy the bootblock into place at the end of the file */
-
- ret = copy_from_fd(fd, ROM_PTR(rom, rom->size - ntohl(rom->header->bootblocksize)), size);
-
- close(fd);
-
- if (ret) {
- ERROR("Unable to add %s to the bootblock\n", filename);
- return -1;
- }
-
- /* FIXME: This should point to a location defined by coreboot */
-
- ROM_WRITEL(rom, rom->size - 4,
- 0xFFFFFFF0 - sizeof(struct romfs_header));
-
- /* This is a pointer to the header for easy access */
- rom->header = (struct romfs_header *)
- ROM_PTR(rom, rom->size - 16 - sizeof(struct romfs_header));
-
-#if 0
- /* Figure out the new location for the header */
- offset = ROM_READL(rom, rom->size - 4);
-
- rom->header = (struct romfs_header *)
- ROM_PTR(rom, offset - (0xFFFFFFFF - rom->size));
-#endif
-
- /* Replace the LAR header */
- memcpy(rom->header, &tmp, sizeof(struct romfs_header));
-
- return 0;
-}
-
-int rom_exists(struct rom *rom)
-{
- if (rom->fd <= 0)
- return 0;
- return 1;
-}
projects / coreboot.git / commitdiff