Lines Matching refs:value
588 // Set SVE/FP registers to a value that is a NaN in both 32-bit and 64-bit FP.
868 void Simulator::SetColouredTrace(bool value) {
869 coloured_trace_ = value;
871 clr_normal = value ? COLOUR(NORMAL) : "";
872 clr_flag_name = value ? COLOUR_BOLD(WHITE) : "";
873 clr_flag_value = value ? COLOUR(NORMAL) : "";
874 clr_reg_name = value ? COLOUR_BOLD(CYAN) : "";
875 clr_reg_value = value ? COLOUR(CYAN) : "";
876 clr_vreg_name = value ? COLOUR_BOLD(MAGENTA) : "";
877 clr_vreg_value = value ? COLOUR(MAGENTA) : "";
878 clr_preg_name = value ? COLOUR_BOLD(GREEN) : "";
879 clr_preg_value = value ? COLOUR(GREEN) : "";
880 clr_memory_address = value ? COLOUR_BOLD(BLUE) : "";
881 clr_warning = value ? COLOUR_BOLD(YELLOW) : "";
882 clr_warning_message = value ? COLOUR(YELLOW) : "";
883 clr_printf = value ? COLOUR(GREEN) : "";
884 clr_branch_marker = value ? COLOUR(GREY) COLOUR_HIGHLIGHT : "";
886 if (value) {
976 // Negate the integer value. Throw an assertion when the input is INT128_MIN.
1066 int64_t value,
1071 value &= kByteMask;
1074 value &= kHalfWordMask;
1077 value &= kWordMask;
1080 value &= kByteMask;
1081 if ((value & 0x80) != 0) {
1082 value |= ~UINT64_C(0) << 8;
1086 value &= kHalfWordMask;
1087 if ((value & 0x8000) != 0) {
1088 value |= ~UINT64_C(0) << 16;
1092 value &= kWordMask;
1093 if ((value & 0x80000000) != 0) {
1094 value |= ~UINT64_C(0) << 32;
1103 return ShiftOperand(reg_size, value, LSL, left_shift);
1333 void Simulator::PrintRegisterValue(const uint8_t* value,
1341 // If we aren't explicitly printing a partial value, ensure that the
1343 VIXL_ASSERT(((format & kPrintRegPartial) != 0) || (value[i] == 0));
1347 fprintf(stream_, "%02x", value[i]);
1351 void Simulator::PrintRegisterValueFPAnnotations(const uint8_t* value,
1363 // way. We squash NaNs, and a double can exactly represent any other value
1370 memcpy(&element_fp16, &value[i * lane_size], sizeof(element_fp16));
1376 memcpy(&element_fp32, &value[i * lane_size], sizeof(element_fp32));
1381 memcpy(&element, &value[i * lane_size], sizeof(element));
1431 // "# x{code}: 0x{-----value----}"
1432 // "# w{code}: 0x{-value}"
1435 // "# x{code}<63:0>: 0x{-----value----}"
1436 // "# x{code}<31:0>: 0x{-value}"
1482 // "# v{code}: 0x{-------------value------------}"
1483 // "# d{code}: 0x{-----value----}"
1484 // "# s{code}: 0x{-value}"
1489 // "# v{code}<127:0>: 0x{-------------value------------}"
1490 // "# v{code}<63:0>: 0x{-----value----}"
1491 // "# v{code}<31:0>: 0x{-value}"
1573 const uint8_t* value = vregisters_[rt_code].GetBytes() + byte_index;
1580 PrintRegisterValueFPAnnotations(value, focus_mask, format_q);
1635 // "# z{code}<127:0>: 0x{-------------value------------}"
1641 const uint8_t* value = vregisters_[code].GetBytes() + byte_index;
1655 PrintRegisterValue(value, size, format);
1658 PrintRegisterValueFPAnnotations(value, GetPrintRegLaneMask(format), format);
1681 // "# {name}<15:0>: 0b{-------------value------------}"
1760 // Indent to match the register field, the fixed formatting, and the value
1820 // "# {reg}: 0x{value} -> {address}"
1839 // "# v{code}: 0x{value} -> {address}"
1859 // "# v{code}: 0x{value}"
1860 // "# ...: 0x{value}"
1890 // "# v{code}: 0x{value}"
1891 // "# ...: 0x{value}"
1908 // "# v{code}: 0x{value}"
1909 // "# ...: 0x{value}"
1923 // "# z{code}<127:0>: 0x{value} -> {address}"
1924 // "# z{code}<255:128>: 0x{value} -> {address + 16}"
1925 // "# z{code}<383:256>: 0x{value} -> {address + 32}"
1953 // "# z{code}<255:128>: 0x{value}"
1954 // "# ...<255:128>: 0x{value}"
2007 // "# p{code}<15:0>: 0b{value} -> {address}"
2008 // "# p{code}<31:16>: 0b{value} -> {address + 2}"
2009 // "# p{code}<47:32>: 0b{value} -> {address + 4}"
2027 void Simulator::PrintMemTransfer(uintptr_t dst, uintptr_t src, uint8_t value) {
2035 value,
2068 // value is different from what is loaded from memory.
2095 // value, only print the relevant part of the value.
2108 // value, only print the relevant part of the value.
3983 uint64_t value = ReadRegister<uint64_t>(instr->GetRn());
3986 uint64_t rotated = RotateRight(value, shift, kXRegSize);
3996 uint32_t value = ReadRegister<uint32_t>(instr->GetRn());
3999 unsigned sign_bit = (value >> msb) & 1;
4000 unsigned overflow_bit = (value >> (msb + 1)) & 1;
4002 ReadNzcv().SetZ((value << (31 - msb)) == 0);
4943 T value = ReadRegister<T>(rs);
4955 result = data + value;
4959 result = data & ~value;
4963 result = data ^ value;
4967 result = data | value;
4973 result = (data > value) ? data : value;
4977 result = (data > value) ? value : data;
5246 // Compute the new value.
5730 // destination register value or in zero.
6823 // TODO: This case depends on the value of SCTLR_EL1.BT0, which we
8105 // NEON indexed `dot` allows the index value exceed the register size.
8185 uint64_t value = LogicVRegister(rn).Uint(vf, reg_index);
8186 value &= MaxUintFromFormat(vf);
8187 WriteXRegister(instr->GetRd(), value);
8189 int64_t value = LogicVRegister(rn).Int(vf, reg_index);
8191 WriteXRegister(instr->GetRd(), value);
8193 WriteWRegister(instr->GetRd(), (int32_t)value);
8357 // Stores don't represent a change to the source register's value, so only
8358 // print the relevant part of the value.
8603 // Stores don't represent a change to the source register's value, so only
8604 // print the relevant part of the value.
8645 // Find the format and immediate value
11766 uint64_t value = FPToRawbitsWithSize(LaneSizeInBitsFromFormat(vform),
11768 dup_immediate(vform, result, value);
13350 std::pair<bool, uint64_t> value = clast(vform, pg, zm, active_offset);
13351 if (value.first) {
13352 dup_immediate(vform, zdn, value.second);
13355 // change the register value.
13410 std::pair<bool, uint64_t> value = clast(vform, pg, zm, active_offset);
13413 WriteXRegister(instr->GetRd(), value.first ? value.second : masked_src);
13439 std::pair<bool, uint64_t> value = clast(vform, pg, zm, active_offset);
13441 dst.SetUint(vform, 0, value.second);
13465 std::pair<bool, uint64_t> value = clast(vform, pg, zm, active_offset);
13466 WriteXRegister(instr->GetRd(), value.second);
14541 // any call returns a negative (error) value, though, just return that value.