Coverage Report

Created: 2019-02-20 07:29

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Bitcode/BitCodes.h
Line
Count
Source
1
//===- BitCodes.h - Enum values for the bitcode format ----------*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// This header Bitcode enum values.
10
//
11
// The enum values defined in this file should be considered permanent.  If
12
// new features are added, they should have values added at the end of the
13
// respective lists.
14
//
15
//===----------------------------------------------------------------------===//
16
17
#ifndef LLVM_BITCODE_BITCODES_H
18
#define LLVM_BITCODE_BITCODES_H
19
20
#include "llvm/ADT/SmallVector.h"
21
#include "llvm/Support/DataTypes.h"
22
#include "llvm/Support/ErrorHandling.h"
23
#include <cassert>
24
25
namespace llvm {
26
/// Offsets of the 32-bit fields of bitcode wrapper header.
27
static const unsigned BWH_MagicField = 0 * 4;
28
static const unsigned BWH_VersionField = 1 * 4;
29
static const unsigned BWH_OffsetField = 2 * 4;
30
static const unsigned BWH_SizeField = 3 * 4;
31
static const unsigned BWH_CPUTypeField = 4 * 4;
32
static const unsigned BWH_HeaderSize = 5 * 4;
33
34
namespace bitc {
35
  enum StandardWidths {
36
    BlockIDWidth   = 8,  // We use VBR-8 for block IDs.
37
    CodeLenWidth   = 4,  // Codelen are VBR-4.
38
    BlockSizeWidth = 32  // BlockSize up to 2^32 32-bit words = 16GB per block.
39
  };
40
41
  // The standard abbrev namespace always has a way to exit a block, enter a
42
  // nested block, define abbrevs, and define an unabbreviated record.
43
  enum FixedAbbrevIDs {
44
    END_BLOCK = 0,  // Must be zero to guarantee termination for broken bitcode.
45
    ENTER_SUBBLOCK = 1,
46
47
    /// DEFINE_ABBREV - Defines an abbrev for the current block.  It consists
48
    /// of a vbr5 for # operand infos.  Each operand info is emitted with a
49
    /// single bit to indicate if it is a literal encoding.  If so, the value is
50
    /// emitted with a vbr8.  If not, the encoding is emitted as 3 bits followed
51
    /// by the info value as a vbr5 if needed.
52
    DEFINE_ABBREV = 2,
53
54
    // UNABBREV_RECORDs are emitted with a vbr6 for the record code, followed by
55
    // a vbr6 for the # operands, followed by vbr6's for each operand.
56
    UNABBREV_RECORD = 3,
57
58
    // This is not a code, this is a marker for the first abbrev assignment.
59
    FIRST_APPLICATION_ABBREV = 4
60
  };
61
62
  /// StandardBlockIDs - All bitcode files can optionally include a BLOCKINFO
63
  /// block, which contains metadata about other blocks in the file.
64
  enum StandardBlockIDs {
65
    /// BLOCKINFO_BLOCK is used to define metadata about blocks, for example,
66
    /// standard abbrevs that should be available to all blocks of a specified
67
    /// ID.
68
    BLOCKINFO_BLOCK_ID = 0,
69
70
    // Block IDs 1-7 are reserved for future expansion.
71
    FIRST_APPLICATION_BLOCKID = 8
72
  };
73
74
  /// BlockInfoCodes - The blockinfo block contains metadata about user-defined
75
  /// blocks.
76
  enum BlockInfoCodes {
77
    // DEFINE_ABBREV has magic semantics here, applying to the current SETBID'd
78
    // block, instead of the BlockInfo block.
79
80
    BLOCKINFO_CODE_SETBID        = 1, // SETBID: [blockid#]
81
    BLOCKINFO_CODE_BLOCKNAME     = 2, // BLOCKNAME: [name]
82
    BLOCKINFO_CODE_SETRECORDNAME = 3  // BLOCKINFO_CODE_SETRECORDNAME:
83
                                      //                             [id, name]
84
  };
85
86
} // End bitc namespace
87
88
/// BitCodeAbbrevOp - This describes one or more operands in an abbreviation.
89
/// This is actually a union of two different things:
90
///   1. It could be a literal integer value ("the operand is always 17").
91
///   2. It could be an encoding specification ("this operand encoded like so").
92
///
93
class BitCodeAbbrevOp {
94
  uint64_t Val;           // A literal value or data for an encoding.
95
  bool IsLiteral : 1;     // Indicate whether this is a literal value or not.
96
  unsigned Enc   : 3;     // The encoding to use.
97
public:
98
  enum Encoding {
99
    Fixed = 1,  // A fixed width field, Val specifies number of bits.
100
    VBR   = 2,  // A VBR field where Val specifies the width of each chunk.
101
    Array = 3,  // A sequence of fields, next field species elt encoding.
102
    Char6 = 4,  // A 6-bit fixed field which maps to [a-zA-Z0-9._].
103
    Blob  = 5   // 32-bit aligned array of 8-bit characters.
104
  };
105
106
2.14M
  explicit BitCodeAbbrevOp(uint64_t V) :  Val(V), IsLiteral(true) {}
107
  explicit BitCodeAbbrevOp(Encoding E, uint64_t Data = 0)
108
3.93M
    : Val(Data), IsLiteral(false), Enc(E) {}
109
110
80.0M
  bool isLiteral() const  { return IsLiteral; }
111
11.6M
  bool isEncoding() const { return !IsLiteral; }
112
113
  // Accessors for literals.
114
19.8M
  uint64_t getLiteralValue() const { assert(isLiteral()); return Val; }
115
116
  // Accessors for encoding info.
117
161M
  Encoding getEncoding() const { assert(isEncoding()); return (Encoding)Enc; }
118
70.5M
  uint64_t getEncodingData() const {
119
70.5M
    assert(isEncoding() && hasEncodingData());
120
70.5M
    return Val;
121
70.5M
  }
122
123
1.38M
  bool hasEncodingData() const { return hasEncodingData(getEncoding()); }
124
3.92M
  static bool hasEncodingData(Encoding E) {
125
3.92M
    switch (E) {
126
3.92M
    case Fixed:
127
3.25M
    case VBR:
128
3.25M
      return true;
129
3.25M
    case Array:
130
671k
    case Char6:
131
671k
    case Blob:
132
671k
      return false;
133
1
    }
134
1
    report_fatal_error("Invalid encoding");
135
1
  }
136
137
  /// isChar6 - Return true if this character is legal in the Char6 encoding.
138
944k
  static bool isChar6(char C) {
139
944k
    if (C >= 'a' && 
C <= 'z'684k
)
return true684k
;
140
260k
    if (C >= 'A' && 
C <= 'Z'51.1k
)
return true26.3k
;
141
233k
    if (C >= '0' && 
C <= '9'123k
)
return true97.8k
;
142
135k
    if (C == '.' || 
C == '_'30.1k
)
return true130k
;
143
5.31k
    return false;
144
5.31k
  }
145
935k
  static unsigned EncodeChar6(char C) {
146
935k
    if (C >= 'a' && 
C <= 'z'681k
)
return C-'a'681k
;
147
254k
    if (C >= 'A' && 
C <= 'Z'51.0k
)
return C-'A'+2626.3k
;
148
228k
    if (C >= '0' && 
C <= '9'122k
)
return C-'0'+26+2697.7k
;
149
130k
    if (C == '.')             
return 62105k
;
150
24.7k
    
if (24.7k
C == '_'24.7k
) return 63;
151
18.4E
    llvm_unreachable("Not a value Char6 character!");
152
18.4E
  }
153
154
108M
  static char DecodeChar6(unsigned V) {
155
108M
    assert((V & ~63) == 0 && "Not a Char6 encoded character!");
156
108M
    return "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789._"
157
108M
        [V];
158
108M
  }
159
160
};
161
162
/// BitCodeAbbrev - This class represents an abbreviation record.  An
163
/// abbreviation allows a complex record that has redundancy to be stored in a
164
/// specialized format instead of the fully-general, fully-vbr, format.
165
class BitCodeAbbrev {
166
  SmallVector<BitCodeAbbrevOp, 32> OperandList;
167
168
public:
169
20.4M
  unsigned getNumOperandInfos() const {
170
20.4M
    return static_cast<unsigned>(OperandList.size());
171
20.4M
  }
172
89.8M
  const BitCodeAbbrevOp &getOperandInfo(unsigned N) const {
173
89.8M
    return OperandList[N];
174
89.8M
  }
175
176
6.06M
  void Add(const BitCodeAbbrevOp &OpInfo) {
177
6.06M
    OperandList.push_back(OpInfo);
178
6.06M
  }
179
};
180
} // End llvm namespace
181
182
#endif