blob: 137b05a5a9aadd49a556432bd6e28a7bbc054c2c [file] [log] [blame]
* Copyright (C) 2016 The Android Open Source Project
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* See the License for the specific language governing permissions and
* limitations under the License.
* This is the relocation format we use for Cortex-M4F cpu. This format is
* consistent with what GCC will produce with our app-compilation flags. So
* what will it produce? Relocs will ONLY be in RAM, always be word-sized,
* always be word-aligned, and never overlap. We use all of that. How do we
* encode? The relocs format is a bytestream. The decoder is conceptually two
* passes, though it can easily be implemented as a single pass. The first pass
* unpacks the bytestream into a list of TOKENS and NUMBERS. The second then
* uses those to reconstruct the list of relocs.
* PASS #1 - unpacking
* Each iteration, it will read a byte from the input byte stream, until none
* are available. This first byte will tell it what to do next. All values that
* are <= MAX_8_BIT_NUM, are put directly as a NUMBER into the output list.
* The remaining possibly values all require special handling, which will be
* described now:
* TOKEN_32BIT_OFST: 4 bytes follow. They are to be treated as a single
* 32-bit little-endian value. This value is put into
* the output list directly as a NUMBER.
* TOKEN_24BIT_OFST: 3 bytes follow. They are to be treated as a single
* 24-bit little-endian value. MAX_16_BIT_NUM is added
* to it, then this value is put into the output list
* as a NUMBER.
* TOKEN_16BIT_OFST: 2 bytes follow. They are to be treated as a single
* 16-bit little-endian value. MAX_8_BIT_NUM is added
* to it, then this value is put into the output list
* as a NUMBER.
* TOKEN_CONSECUTIVE: 1 byte follows. It is read, MIN_RUN_LEN is added to
* it. That many zero-valued NUMBERS are added to the
* output list.
* TOKEN_RELOC_TYPE_CHG: 1 byte follows. It is read, one is added to it, and
* a TYPE_CHANGE token with that value is added to the
* output list.
* TOKEN_RELOC_TYPE_NEXT: a TYPE_CHANGE token with a value of 1 is added to
* the output list.
* PASS #2 - decoding
* The decoder is stateful. Initially the decoder state is representable as:
* {reloc_type: 0, ofst: 0}. The decoder will work by removig one item at a
* time from the head of the list generated by PASS #1, and acting on it, until
* no more exist. It will produce {reloc_type, reloc_offset} tuples, which can
* then be used to perform actual relocations. Unpon reading a TYPE_CHANGE
* token, "reloc_type" in the decoder's state shall be incremented by the value
* the token carries, and "ofst" shall be set to zero. Upon reading a NUMBER,
* the decoder shall:
* a. calculate t = "ofst" + (that NUMBER's value) * 4
* b. store t + 4 into "ofst"
* c. produce an output tuple {"reloc_type", t}
* At the end of these two passes a list of tuples exists that has all reloc types
* and offsets. this list can be easily walked and relocations performed.
//offset is always from previous reloc's NEXT word!
#define TOKEN_RELOC_TYPE_NEXT 0xFF // reloc type changed to previous + 1
#define TOKEN_RELOC_TYPE_CHG 0xFE // reloc type changed (followed by a byte represeting "reloc_type" increment minus 1)
#define TOKEN_CONSECUTIVE 0xFD // followed by 8-bit number of directly following words to relocate (in addition to the one we relocated using previous reloc) minus 3 (2 is break-even point)
#define TOKEN_16BIT_OFST 0xFC // followed by 16-bit x, such that the value we want to represent is x + MAX_8_BIT_NUM
#define TOKEN_24BIT_OFST 0xFB // followed by 24-bit x, such that the value we want to represent is x + MAX_16_BIT_NUM
#define TOKEN_32BIT_OFST 0xFA // followed by 32-bit value we want to represent, sent directly
#define MAX_8_BIT_NUM 0xF9
#define MAX_16_BIT_NUM (0xFFFF + MAX_8_BIT_NUM)
#define MAX_24_BIT_NUM (0xFFFFFF + MAX_16_BIT_NUM)
#define MIN_RUN_LEN 3 //run count does not include first element
#define MAX_RUN_LEN (0xff + MIN_RUN_LEN)