| /src/external/apache2/llvm/dist/llvm/include/llvm/Support/ |
| LEB128.h | 29 // NOTE: this assumes that this signed shift is an arithmetic right shift.
58 // NOTE: this assumes that this signed shift is an arithmetic right shift.
133 unsigned Shift = 0;
145 if ((Shift >= 64 && Slice != 0) || Slice << Shift >> Shift != Slice) {
152 Value += Slice << Shift;
153 Shift += 7
[all...] |
| ScaledNumber.h | 87 // Shift right and round.
88 int Shift = 64 - Width - countLeadingZeros(Digits);
89 return getRounded<DigitsT>(Digits >> Shift, Scale + Shift,
90 Digits & (UINT64_C(1) << (Shift - 1)));
276 /// scales in place. Shift the digits as necessary to form equivalent numbers,
306 // Shift LDigits left as much as possible, then shift RDigits right.
308 assert(ShiftL < getWidth<DigitsT>() && "can't shift more than width");
623 ScaledNumber &operator<<=(int16_t Shift) {
[all...] |
| MathExtras.h | 99 T Shift = std::numeric_limits<T>::digits >> 1;
100 T Mask = std::numeric_limits<T>::max() >> Shift;
101 while (Shift) {
103 Val >>= Shift;
104 ZeroBits |= Shift;
106 Shift >>= 1;
107 Mask >>= Shift;
171 for (T Shift = std::numeric_limits<T>::digits >> 1; Shift; Shift >>= 1)
[all...] |
| LowLevelTypeImpl.h | 265 static uint64_t maskAndShift(uint64_t Val, uint64_t Mask, uint8_t Shift) {
267 return (Val & Mask) << Shift;
|
| /src/external/apache2/llvm/dist/llvm/lib/Support/ |
| ScaledNumber.cpp | 46 // Shift as little as possible to maximize precision.
48 int Shift = 64 - LeadingZeros;
50 Upper = Upper << LeadingZeros | Lower >> Shift;
51 return getRounded(Upper, Shift,
52 Shift && (Lower & UINT64_C(1) << (Shift - 1)));
64 int Shift = 0;
66 Shift -= Zeros;
74 return getAdjusted<uint32_t>(Quotient, Shift);
77 return getRounded<uint32_t>(Quotient, Shift, Remainder >= getHalf(Divisor))
[all...] |
| KnownBits.cpp | 171 // If the shift amount is a valid constant then transform LHS directly.
173 unsigned Shift = RHS.getConstant().getZExtValue();
175 Known.Zero <<= Shift;
176 Known.One <<= Shift;
178 Known.Zero.setLowBits(Shift);
182 // No matter the shift amount, the trailing zeros will stay zero.
185 // Minimum shift amount low bits are known zero.
192 // If the maximum shift is in range, then find the common bits from all
198 assert(MinShiftAmount.ult(MaxShiftAmount) && "Illegal shift range");
204 // Skip if the shift amount is impossible
[all...] |
| /src/external/apache2/llvm/dist/clang/include/clang/Basic/ |
| OperatorPrecedence.h | 39 Shift = 12, // <<, >>
|
| LangOptions.h | 464 static constexpr storage_type NAME##Shift = \
465 PREVIOUS##Shift + PREVIOUS##Width; \
468 << NAME##Shift;
549 return static_cast<TYPE>((Value & NAME##Mask) >> NAME##Shift); \
552 Value = (Value & ~NAME##Mask) | (storage_type(value) << NAME##Shift); \
|
| /src/external/apache2/llvm/dist/llvm/lib/Target/AArch64/ |
| AArch64ExpandImm.cpp | 269 unsigned Shift = 0; // LSL amount for high bits with MOVZ/MOVN
274 Shift = (TZ / 16) * 16;
277 unsigned Imm16 = (Imm >> Shift) & Mask;
280 AArch64_AM::getShifterImm(AArch64_AM::LSL, Shift) });
282 if (Shift == LastShift)
291 while (Shift < LastShift) {
292 Shift += 16;
293 Imm16 = (Imm >> Shift) & Mask;
298 AArch64_AM::getShifterImm(AArch64_AM::LSL, Shift) });
312 for (unsigned Shift = 0; Shift < BitSize; Shift += 16)
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/ADT/ |
| PointerEmbeddedInt.h | 42 // We shift as many zeros into the value as we can while preserving the
44 Shift = sizeof(uintptr_t) * CHAR_BIT - Bits,
66 Value = static_cast<uintptr_t>(I) << Shift;
74 return static_cast<IntT>(static_cast<intptr_t>(Value) >> Shift);
75 return static_cast<IntT>(Value >> Shift);
97 static constexpr int NumLowBitsAvailable = T::Shift;
|
| Bitfields.h | 96 /// undefined operations over signed types (e.g. Bitwise shift operators).
166 static constexpr StorageType Mask = BP::Umax << Bitfield::Shift;
173 Packed |= StorageValue << Bitfield::Shift;
179 const StorageType StorageValue = (Packed & Mask) >> Bitfield::Shift;
227 static constexpr unsigned Shift = Offset;
230 static constexpr unsigned LastBit = Shift + Bits - 1;
231 static constexpr unsigned NextBit = Shift + Bits;
|
| /src/external/apache2/llvm/dist/clang/lib/Basic/ |
| OperatorPrecedence.cpp | 37 return prec::Shift;
66 case tok::lessless: return prec::Shift;
|
| /src/external/apache2/llvm/dist/llvm/lib/Target/AMDGPU/Utils/ |
| AMDKernelCodeTInfo.h | 34 #define CODEPROP(name, shift) \
35 RECORD(name, name, PRINTCODEPROP(shift), PARSECODEPROP(shift))
38 #define PRINTCOMP(GetMacro, Shift) \
41 (int)GetMacro(C.compute_pgm_resource_registers >> Shift); \
43 #define PARSECOMP(SetMacro, Shift) \
48 C.compute_pgm_resource_registers &= ~(SetMacro(0xFFFFFFFFFFFFFFFFULL) << Shift); \
49 C.compute_pgm_resource_registers |= SetMacro(Value) << Shift; \
53 #define COMPPGM(name, aname, GetMacro, SetMacro, Shift) \
54 RECORD(name, aname, PRINTCOMP(GetMacro, Shift), PARSECOMP(SetMacro, Shift)
[all...] |
| /src/external/bsd/libarchive/dist/libarchive/ |
| archive_ppmd_private.h | 93 #define PPMD_GET_MEAN_SPEC(summ, shift, round) (((summ) + (1 << ((shift) - (round)))) >> (shift))
108 Byte Shift; /* Speed of Freq change; low Shift is for fast change */
109 Byte Count; /* Count to next change of Shift */
113 if ((p)->Shift < PPMD_PERIOD_BITS && --(p)->Count == 0) { \
115 (p)->Count = (Byte)(3 << (p)->Shift++); \
|
| /src/external/apache2/llvm/dist/llvm/utils/TableGen/ |
| CodeBeadsGen.cpp | 103 unsigned Shift = i % 8;
105 Value |= (static_cast<uint8_t>(B->getValue()) << Shift);
|
| /src/external/apache2/llvm/dist/clang/lib/Format/ |
| WhitespaceManager.cpp | 268 int Shift = 0;
315 Shift = 0;
324 Shift = Column - Changes[i].StartOfTokenColumn;
325 Changes[i].Spaces += Shift;
361 Changes[i].Spaces += Shift;
365 Changes[i].Spaces += Shift;
367 assert(Shift >= 0);
368 Changes[i].StartOfTokenColumn += Shift;
370 Changes[i + 1].PreviousEndOfTokenColumn += Shift;
554 int Shift = 0
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Utils/ |
| IntegerDivision.cpp | 36 ConstantInt *Shift;
39 Shift = Builder.getInt64(63);
42 Shift = Builder.getInt32(31);
45 // Following instructions are generated for both i32 (shift 31) and
46 // i64 (shift 63).
57 Value *DividendSign = Builder.CreateAShr(Dividend, Shift);
58 Value *DivisorSign = Builder.CreateAShr(Divisor, Shift);
108 ConstantInt *Shift;
111 Shift = Builder.getInt64(63);
114 Shift = Builder.getInt32(31)
[all...] |
| /src/external/gpl3/gdb.old/dist/sim/aarch64/ |
| decode.h | 77 log(bytes in data element - 1) as the shift count.
112 optionally perform a shift on the second register value. */
114 typedef enum Shift
120 } Shift;
154 /* Pick bits [hi,...,lo] from val and shift to [(hi-(newlo - lo)),newlo]. */
166 /* Mask [hi,lo] and shift down to start at bit 0. */
173 /* Mask [hi,lo] and shift down to start at bit 0. */
|
| /src/external/gpl3/gdb/dist/sim/aarch64/ |
| decode.h | 77 log(bytes in data element - 1) as the shift count.
112 optionally perform a shift on the second register value. */
114 typedef enum Shift
120 } Shift;
154 /* Pick bits [hi,...,lo] from val and shift to [(hi-(newlo - lo)),newlo]. */
166 /* Mask [hi,lo] and shift down to start at bit 0. */
173 /* Mask [hi,lo] and shift down to start at bit 0. */
|
| /src/external/apache2/llvm/dist/clang/include/clang/Tooling/ASTDiff/ |
| ASTDiff.h | 39 int Depth, Height, Shift = 0;
|
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/InstCombine/ |
| InstCombinePHI.cpp | 858 // Can fold binop, compare or shift here if the RHS is a constant,
994 unsigned Shift; // The amount shifted.
998 : PHIId(pn), Shift(Sh), Inst(User) {}
1003 if (Shift < RHS.Shift) return true;
1004 if (Shift > RHS.Shift) return false;
1012 unsigned Shift; // The amount shifted.
1016 : PN(pn), Shift(Sh), Width(Ty->getPrimitiveSizeInBits()) {}
1020 : PN(pn), Shift(Sh), Width(0) {
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Analysis/ |
| BlockFrequencyInfoImpl.cpp | 214 static uint64_t shiftRightAndRound(uint64_t N, int Shift) {
215 assert(Shift >= 0);
216 assert(Shift < 64);
217 if (!Shift)
219 return (N >> Shift) + (UINT64_C(1) & N >> (Shift - 1));
238 // Determine how much to shift right so that the total fits into 32-bits.
240 // If we shift at all, shift by 1 extra. Otherwise, the lower limit of 1
242 int Shift = 0
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Target/Mips/ |
| MicroMipsSizeReduction.cpp | 52 ImmField() : ImmFieldOperand(-1), Shift(0), LBound(0), HBound(0) {}
53 ImmField(uint8_t Shift, int16_t LBound, int16_t HBound,
55 : ImmFieldOperand(ImmFieldOperand), Shift(Shift), LBound(LBound),
58 uint8_t Shift; // Shift value
105 uint8_t Shift() const { return Imm.Shift; }
213 // ImmField(Shift, LBound, HBound, ImmFieldPosition)
326 // bits equal to Shift and if the shifted value is between the bounds
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Target/AArch64/MCTargetDesc/ |
| AArch64AddressingModes.h | 51 /// getShiftName - Get the string encoding for the shift type.
54 default: llvm_unreachable("unhandled shift type!");
72 /// getShiftType - Extract the shift type.
84 /// getShiftValue - Extract the shift value.
89 /// getShifterImm - Encode the shift type and amount:
90 /// imm: 6-bit shift amount
103 default: llvm_unreachable("Invalid shift requested");
117 /// getArithShiftValue - get the arithmetic shift value.
165 /// getArithExtendImm - Encode the extend type and shift amount for an
176 /// getMemDoShift - Extract the "do shift" flag value for load/stor
[all...] |
| /src/sys/external/bsd/compiler_rt/dist/lib/builtins/ |
| fp_add_impl.inc | 74 // Shift the significands to give us round, guard and sticky, and or in the
81 // Shift the significand of b by the difference in exponents, with a sticky
97 // If partial cancellation occured, we need to left-shift the result
100 const int shift = rep_clz(aSignificand) - rep_clz(implicitBit << 3);
101 aSignificand <<= shift;
102 aExponent -= shift;
108 // If the addition carried up, we need to right-shift the result and
122 // need to shift the significand.
123 const int shift = 1 - aExponent;
124 const bool sticky = aSignificand << (typeWidth - shift);
[all...] |
