Coverage Report

Created: 2018-09-25 23:22

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h
Line
Count
Source
1
//== APSIntType.h - Simple record of the type of APSInts --------*- C++ -*--==//
2
//
3
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
10
#ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_APSINTTYPE_H
11
#define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_APSINTTYPE_H
12
13
#include "llvm/ADT/APSInt.h"
14
#include <tuple>
15
16
namespace clang {
17
namespace ento {
18
19
/// A record of the "type" of an APSInt, used for conversions.
20
class APSIntType {
21
  uint32_t BitWidth;
22
  bool IsUnsigned;
23
24
public:
25
  APSIntType(uint32_t Width, bool Unsigned)
26
697k
    : BitWidth(Width), IsUnsigned(Unsigned) {}
27
28
  /* implicit */ APSIntType(const llvm::APSInt &Value)
29
635k
    : BitWidth(Value.getBitWidth()), IsUnsigned(Value.isUnsigned()) {}
30
31
307k
  uint32_t getBitWidth() const { return BitWidth; }
32
247k
  bool isUnsigned() const { return IsUnsigned; }
33
34
  /// Convert a given APSInt, in place, to match this type.
35
  ///
36
  /// This behaves like a C cast: converting 255u8 (0xFF) to s16 gives
37
  /// 255 (0x00FF), and converting -1s8 (0xFF) to u16 gives 65535 (0xFFFF).
38
846k
  void apply(llvm::APSInt &Value) const {
39
846k
    // Note the order here. We extend first to preserve the sign, if this value
40
846k
    // is signed, /then/ match the signedness of the result type.
41
846k
    Value = Value.extOrTrunc(BitWidth);
42
846k
    Value.setIsUnsigned(IsUnsigned);
43
846k
  }
44
45
  /// Convert and return a new APSInt with the given value, but this
46
  /// type's bit width and signedness.
47
  ///
48
  /// \see apply
49
330k
  llvm::APSInt convert(const llvm::APSInt &Value) const LLVM_READONLY {
50
330k
    llvm::APSInt Result(Value, Value.isUnsigned());
51
330k
    apply(Result);
52
330k
    return Result;
53
330k
  }
54
55
  /// Returns an all-zero value for this type.
56
208k
  llvm::APSInt getZeroValue() const LLVM_READONLY {
57
208k
    return llvm::APSInt(BitWidth, IsUnsigned);
58
208k
  }
59
60
  /// Returns the minimum value for this type.
61
159k
  llvm::APSInt getMinValue() const LLVM_READONLY {
62
159k
    return llvm::APSInt::getMinValue(BitWidth, IsUnsigned);
63
159k
  }
64
65
  /// Returns the maximum value for this type.
66
127k
  llvm::APSInt getMaxValue() const LLVM_READONLY {
67
127k
    return llvm::APSInt::getMaxValue(BitWidth, IsUnsigned);
68
127k
  }
69
70
194k
  llvm::APSInt getValue(uint64_t RawValue) const LLVM_READONLY {
71
194k
    return (llvm::APSInt(BitWidth, IsUnsigned) = RawValue);
72
194k
  }
73
74
  /// Used to classify whether a value is representable using this type.
75
  ///
76
  /// \see testInRange
77
  enum RangeTestResultKind {
78
    RTR_Below = -1, ///< Value is less than the minimum representable value.
79
    RTR_Within = 0, ///< Value is representable using this type.
80
    RTR_Above = 1   ///< Value is greater than the maximum representable value.
81
  };
82
83
  /// Tests whether a given value is losslessly representable using this type.
84
  ///
85
  /// \param Val The value to test.
86
  /// \param AllowMixedSign Whether or not to allow signedness conversions.
87
  ///                       This determines whether -1s8 is considered in range
88
  ///                       for 'unsigned char' (u8).
89
  RangeTestResultKind testInRange(const llvm::APSInt &Val,
90
                                  bool AllowMixedSign) const LLVM_READONLY;
91
92
28.7k
  bool operator==(const APSIntType &Other) const {
93
28.7k
    return BitWidth == Other.BitWidth && 
IsUnsigned == Other.IsUnsigned26.7k
;
94
28.7k
  }
95
96
  /// Provide an ordering for finding a common conversion type.
97
  ///
98
  /// Unsigned integers are considered to be better conversion types than
99
  /// signed integers of the same width.
100
164k
  bool operator<(const APSIntType &Other) const {
101
164k
    return std::tie(BitWidth, IsUnsigned) <
102
164k
           std::tie(Other.BitWidth, Other.IsUnsigned);
103
164k
  }
104
};
105
106
} // end ento namespace
107
} // end clang namespace
108
109
#endif