Home | History | Annotate | Download | only in Wrap
      1 /*
      2  * Copyright 2012, The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *     http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 // Define utility class to wrap/unwrap bitcode files. Does wrapping/unwrapping
     18 // in such a way that the wrappered bitcode file is still a bitcode file.
     19 
     20 #ifndef LLVM_WRAP_BITCODE_WRAPPERER_H__
     21 #define LLVM_WRAP_BITCODE_WRAPPERER_H__
     22 
     23 #include <stdint.h>
     24 #include <stddef.h>
     25 #include <vector>
     26 
     27 #include "bcinfo/Wrap/support_macros.h"
     28 #include "bcinfo/Wrap/BCHeaderField.h"
     29 #include "bcinfo/Wrap/wrapper_input.h"
     30 #include "bcinfo/Wrap/wrapper_output.h"
     31 
     32 // The bitcode wrapper header is the following 7 fixed 4-byte fields:
     33 //      1) 0B17C0DE - The magic number expected by llvm for wrapped bitcodes
     34 //      2) Version # 0 - The current version of wrapped bitcode files
     35 //      3) (raw) bitcode offset
     36 //      4) (raw) bitcode size
     37 //      5) Android header version
     38 //      6) Android target API
     39 //      7) PNaCl Bitcode version
     40 //      plus 0 or more variable-length fields (consisting of ID, length, data)
     41 
     42 // Initial buffer size. It is expanded if needed to hold large variable-size
     43 // fields.
     44 static const size_t kBitcodeWrappererBufferSize = 1024;
     45 
     46 // Support class for outputting a wrapped bitcode file from a raw bitcode
     47 // file (and optionally additional header fields), or for outputting a raw
     48 // bitcode file from a wrapped one.
     49 class BitcodeWrapperer {
     50  public:
     51   // Create a bitcode wrapperer using the following
     52   // input and output files.
     53   BitcodeWrapperer(WrapperInput* infile, WrapperOutput* outfile);
     54 
     55   // Returns true if the input file begins with a bitcode
     56   // wrapper magic number. As a side effect, _wrapper_ fields are set.
     57   bool IsInputBitcodeWrapper();
     58 
     59   // Returns true if the input file begins with a bitcode
     60   // file magic number.
     61   bool IsInputBitcodeFile();
     62 
     63   // Add a variable-length field to the header. The caller is responsible
     64   // for freeing the data pointed to by the BCHeaderField.
     65   void AddHeaderField(BCHeaderField* field);
     66 
     67   // Generate a wrapped bitcode file from the input bitcode file
     68   // and the current header data. Return true on success.
     69   bool GenerateWrappedBitcodeFile();
     70 
     71   // Unwrap the wrapped bitcode file, to the corresponding
     72   // outfile. Return true on success.
     73   bool GenerateRawBitcodeFile();
     74 
     75   // Print current wrapper header fields to stderr for debugging.
     76   void PrintWrapperHeader();
     77 
     78   uint32_t getAndroidHeaderVersion() {
     79     return android_header_version_;
     80   }
     81 
     82   uint32_t getAndroidTargetAPI() {
     83     return android_target_api_;
     84   }
     85 
     86   uint32_t getAndroidCompilerVersion() {
     87     return android_compiler_version_;
     88   }
     89 
     90   uint32_t getAndroidOptimizationLevel() {
     91     return android_optimization_level_;
     92   }
     93 
     94   ~BitcodeWrapperer();
     95 
     96  private:
     97   DISALLOW_CLASS_COPY_AND_ASSIGN(BitcodeWrapperer);
     98 
     99   // Refills the buffer with more bytes. Does this in a way
    100   // such that it is maximally filled.
    101   void FillBuffer();
    102 
    103   // Returns the number of bytes in infile.
    104   off_t GetInFileSize() {
    105     if (infile_ != NULL) {
    106       return infile_->Size();
    107     } else {
    108       return 0;
    109     }
    110   }
    111 
    112   // Returns the offset of bitcode (i.e. the size of the wrapper header)
    113   // if the output file were to be written now.
    114   size_t BitcodeOffset();
    115 
    116   // Returns true if we can read a word. If necessary, fills the buffer
    117   // with enough characters so that there are at least a 32-bit value
    118   // in the buffer. Returns false if there isn't a 32-bit value
    119   // to read from the input file.
    120   bool CanReadWord();
    121 
    122   // Read a (32-bit) word from the input. Return true
    123   // if able to read the word.
    124   bool ReadWord(uint32_t& word);
    125 
    126   // Write a (32-bit) word to the output. Return true if successful
    127   bool WriteWord(uint32_t word);
    128 
    129   // Write all variable-sized header fields to the output. Return true
    130   // if successful.
    131   bool WriteVariableFields();
    132 
    133   // Parse the bitcode wrapper header in the infile, if any. Return true
    134   // if successful.
    135   bool ParseWrapperHeader();
    136 
    137   // Returns the i-th character in front of the cursor in the buffer.
    138   uint8_t BufferLookahead(int i) { return buffer_[cursor_ + i]; }
    139 
    140   // Returns how many unread bytes are in the buffer.
    141   size_t GetBufferUnreadBytes() { return buffer_size_ - cursor_; }
    142 
    143 
    144   // Backs up the read cursor to the beginning of the input buffer.
    145   void ResetCursor() {
    146     cursor_ = 0;
    147   }
    148 
    149   // Generates the header sequence for the wrapped bitcode being
    150   // generated.
    151   bool WriteBitcodeWrapperHeader();
    152 
    153   // Copies size bytes of infile to outfile, using the buffer.
    154   bool BufferCopyInToOut(uint32_t size);
    155 
    156   // Discards the old infile and replaces it with the given file.
    157   void ReplaceInFile(WrapperInput* new_infile);
    158 
    159   // Discards the old outfile and replaces it with the given file.
    160   void ReplaceOutFile(WrapperOutput* new_outfile);
    161 
    162   // Moves to the given position in the input file. Returns false
    163   // if unsuccessful.
    164   bool Seek(uint32_t pos);
    165 
    166   // Clear the buffer of all contents.
    167   void ClearBuffer();
    168 
    169   // The input file being processed. Can be either
    170   // a bitcode file, a wrappered bitcode file, or a secondary
    171   // file to be wrapped.
    172   WrapperInput* infile_;
    173 
    174   // The output file being generated. Can be either
    175   // a bitcode file, a wrappered bitcode file, or a secondary
    176   // unwrapped file.
    177   WrapperOutput* outfile_;
    178 
    179   // A buffer of bytes read from the input file.
    180   std::vector<uint8_t> buffer_;
    181 
    182   // The number of bytes that were read from the input file
    183   // into the buffer.
    184   size_t buffer_size_;
    185 
    186   // The index to the current read point within the buffer.
    187   size_t cursor_;
    188 
    189   // True when eof of input is reached.
    190   bool infile_at_eof_;
    191 
    192   // The 32-bit value defining the offset of the raw bitcode in the input file.
    193   uint32_t infile_bc_offset_;
    194 
    195   // The 32-bit value defining the generated offset of the wrapped bitcode.
    196   // This value changes as new fields are added with AddHeaderField
    197   uint32_t wrapper_bc_offset_;
    198 
    199   // The 32-bit value defining the size of the raw wrapped bitcode.
    200   uint32_t wrapper_bc_size_;
    201 
    202   // Android header version and target API
    203   uint32_t android_header_version_;
    204   uint32_t android_target_api_;
    205   uint32_t android_compiler_version_;
    206   uint32_t android_optimization_level_;
    207 
    208   // PNaCl bitcode version
    209   uint32_t pnacl_bc_version_;
    210 
    211   // Vector of variable header fields
    212   std::vector<BCHeaderField> header_fields_;
    213   // If any bufferdata from header fields is owned, it is stored here and
    214   // freed on destruction.
    215   std::vector<uint8_t*> variable_field_data_;
    216 
    217   // True if there was an error condition (e.g. the file is not bitcode)
    218   bool error_;
    219 };
    220 
    221 #endif  // LLVM_WRAP_BITCODE_WRAPPERER_H__
    222