utils-vixl.cc revision b78f13911bfe6eda303e91ef215c87a165aae8ae 
1// Copyright 2015, VIXL authors
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are met:
6//
7//   * Redistributions of source code must retain the above copyright notice,
8//     this list of conditions and the following disclaimer.
9//   * Redistributions in binary form must reproduce the above copyright notice,
10//     this list of conditions and the following disclaimer in the documentation
11//     and/or other materials provided with the distribution.
12//   * Neither the name of ARM Limited nor the names of its contributors may be
13//     used to endorse or promote products derived from this software without
14//     specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND
17// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
20// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
23// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
27#include <stdio.h>
28
29#include "utils-vixl.h"
30
31namespace vixl {
32
33uint32_t FloatToRawbits(float value) {
34  uint32_t bits = 0;
35  memcpy(&bits, &value, 4);
36  return bits;
37}
38
39
40uint64_t DoubleToRawbits(double value) {
41  uint64_t bits = 0;
42  memcpy(&bits, &value, 8);
43  return bits;
44}
45
46
47float RawbitsToFloat(uint32_t bits) {
48  float value = 0.0;
49  memcpy(&value, &bits, 4);
50  return value;
51}
52
53
54double RawbitsToDouble(uint64_t bits) {
55  double value = 0.0;
56  memcpy(&value, &bits, 8);
57  return value;
58}
59
60
61uint32_t FloatSign(float val) {
62  uint32_t rawbits = FloatToRawbits(val);
63  return ExtractUnsignedBitfield32(31, 31, rawbits);
64}
65
66
67uint32_t FloatExp(float val) {
68  uint32_t rawbits = FloatToRawbits(val);
69  return ExtractUnsignedBitfield32(30, 23, rawbits);
70}
71
72
73uint32_t FloatMantissa(float val) {
74  uint32_t rawbits = FloatToRawbits(val);
75  return ExtractUnsignedBitfield32(22, 0, rawbits);
76}
77
78
79uint32_t DoubleSign(double val) {
80  uint64_t rawbits = DoubleToRawbits(val);
81  return static_cast<uint32_t>(ExtractUnsignedBitfield64(63, 63, rawbits));
82}
83
84
85uint32_t DoubleExp(double val) {
86  uint64_t rawbits = DoubleToRawbits(val);
87  return static_cast<uint32_t>(ExtractUnsignedBitfield64(62, 52, rawbits));
88}
89
90
91uint64_t DoubleMantissa(double val) {
92  uint64_t rawbits = DoubleToRawbits(val);
93  return ExtractUnsignedBitfield64(51, 0, rawbits);
94}
95
96
97float FloatPack(uint32_t sign, uint32_t exp, uint32_t mantissa) {
98  uint32_t bits = (sign << 31) | (exp << 23) | mantissa;
99  return RawbitsToFloat(bits);
100}
101
102
103double DoublePack(uint64_t sign, uint64_t exp, uint64_t mantissa) {
104  uint64_t bits = (sign << 63) | (exp << 52) | mantissa;
105  return RawbitsToDouble(bits);
106}
107
108
109int Float16Classify(float16 value) {
110  uint16_t exponent_max = (1 << 5) - 1;
111  uint16_t exponent_mask = exponent_max << 10;
112  uint16_t mantissa_mask = (1 << 10) - 1;
113
114  uint16_t exponent = (value & exponent_mask) >> 10;
115  uint16_t mantissa = value & mantissa_mask;
116  if (exponent == 0) {
117    if (mantissa == 0) {
118      return FP_ZERO;
119    }
120    return FP_SUBNORMAL;
121  } else if (exponent == exponent_max) {
122    if (mantissa == 0) {
123      return FP_INFINITE;
124    }
125    return FP_NAN;
126  }
127  return FP_NORMAL;
128}
129
130
131unsigned CountClearHalfWords(uint64_t imm, unsigned reg_size) {
132  VIXL_ASSERT((reg_size % 8) == 0);
133  int count = 0;
134  for (unsigned i = 0; i < (reg_size / 16); i++) {
135    if ((imm & 0xffff) == 0) {
136      count++;
137    }
138    imm >>= 16;
139  }
140  return count;
141}
142
143
144int BitCount(uint64_t value) { return CountSetBits(value); }
145
146
147Int64 BitCount(Uint32 value) { return CountSetBits(value.Get()); }
148
149}  // namespace vixl
150