Lines Matching refs:format
708 // clang-format off
768 // clang-format on
1157 uint32_t format = 0;
1164 format = kPrintRegAsQVector;
1167 format = kPrintRegAsDVector;
1177 format |= kPrintReg1Q;
1180 format |= kPrintReg1D;
1183 format |= kPrintReg1S;
1186 format |= kPrintReg1H;
1189 format |= kPrintReg1B;
1198 return static_cast<PrintRegisterFormat>(format);
1335 PrintRegisterFormat format) {
1336 int print_width = GetPrintRegSizeInBytes(format);
1343 VIXL_ASSERT(((format & kPrintRegPartial) != 0) || (value[i] == 0));
1353 PrintRegisterFormat format) {
1354 VIXL_ASSERT((format & kPrintRegAsFP) != 0);
1355 int lane_size = GetPrintRegLaneSizeInBytes(format);
1359 for (int i = GetPrintRegLaneCount(format) - 1; i >= 0; i--, sep = ", ") {
1362 // Read the lane as a double, so we can format all FP types in the same
1412 PrintRegisterFormat format,
1416 VIXL_ASSERT((format & kPrintRegAsVectorMask) == kPrintRegAsScalar);
1417 VIXL_ASSERT((format & kPrintRegAsFP) == 0);
1440 bool is_partial = (format & kPrintRegPartial) != 0;
1441 unsigned print_reg_size = GetPrintRegSizeInBits(format);
1444 name << XRegNameForCode(code) << GetPartialRegSuffix(format);
1468 PrintRegisterValue(*reg, format);
1473 PrintRegisterFormat format,
1476 VIXL_ASSERT(((format & kPrintRegAsVectorMask) == kPrintRegAsScalar) ||
1477 ((format & kPrintRegAsVectorMask) == kPrintRegAsDVector) ||
1478 ((format & kPrintRegAsVectorMask) == kPrintRegAsQVector));
1495 bool is_partial = ((format & kPrintRegPartial) != 0);
1497 unsigned print_reg_size = GetPrintRegSizeInBits(format);
1499 name << VRegNameForCode(code) << GetPartialRegSuffix(format);
1532 PrintRegisterValue(vregisters_[code], format);
1534 if ((format & kPrintRegAsFP) != 0) {
1535 PrintRegisterValueFPAnnotations(vregisters_[code], format);
1543 PrintRegisterFormat format) {
1544 bool print_fp = (format & kPrintRegAsFP) != 0;
1547 static_cast<PrintRegisterFormat>(format & ~kPrintRegAsFP);
1553 PrintRegisterValueFPAnnotations(vregisters_[code], focus_mask, format);
1563 PrintRegisterFormat format) {
1564 bool print_fp = (format & kPrintRegAsFP) != 0;
1567 static_cast<PrintRegisterFormat>(format & ~kPrintRegAsFP);
1569 PrintRegisterFormat format_q = GetPrintRegAsQChunkOfSVE(format);
1586 void Simulator::PrintZRegister(int code, PrintRegisterFormat format) {
1587 // We're going to print the register in parts, so force a partial format.
1588 format = GetPrintRegPartial(format);
1589 VIXL_ASSERT((format & kPrintRegAsVectorMask) == kPrintRegAsSVEVector);
1593 PrintPartialZRegister(code, i, format);
1598 void Simulator::PrintPRegister(int code, PrintRegisterFormat format) {
1599 // We're going to print the register in parts, so force a partial format.
1600 format = GetPrintRegPartial(format);
1601 VIXL_ASSERT((format & kPrintRegAsVectorMask) == kPrintRegAsSVEVector);
1605 PrintPartialPRegister(code, i, format);
1610 void Simulator::PrintFFR(PrintRegisterFormat format) {
1611 // We're going to print the register in parts, so force a partial format.
1612 format = GetPrintRegPartial(format);
1613 VIXL_ASSERT((format & kPrintRegAsVectorMask) == kPrintRegAsSVEVector);
1618 PrintPartialPRegister("FFR", ffr, i, format);
1625 PrintRegisterFormat format,
1628 VIXL_ASSERT((format & kPrintRegAsVectorMask) == kPrintRegAsSVEVector);
1629 VIXL_ASSERT((format & kPrintRegPartial) != 0);
1637 format = GetPrintRegAsQChunkOfSVE(format);
1655 PrintRegisterValue(value, size, format);
1657 if ((format & kPrintRegAsFP) != 0) {
1658 PrintRegisterValueFPAnnotations(value, GetPrintRegLaneMask(format), format);
1666 PrintRegisterFormat format,
1668 VIXL_ASSERT((format & kPrintRegAsVectorMask) == kPrintRegAsSVEVector);
1669 VIXL_ASSERT((format & kPrintRegPartial) != 0);
1672 // We don't currently use the format for anything here.
1673 USE(format);
1703 PrintRegisterFormat format,
1709 format,
1809 PrintRegisterFormat format,
1812 VIXL_ASSERT(GetPrintRegLaneCount(format) == 1);
1814 if ((format & kPrintRegPartial) == 0) {
1819 // Scalar-format accesses use a simple format:
1823 PrintRegister(code, format, "");
1833 PrintRegisterFormat format,
1838 // Scalar-format accesses use a simple format:
1842 PrintVRegister(code, format, "");
1853 PrintRegisterFormat format,
1864 uint16_t lane_mask = GetPrintRegLaneMask(format);
1865 PrintVRegistersForStructuredAccess(rt_code, reg_count, lane_mask, format);
1867 int reg_size_in_bytes = GetPrintRegSizeInBytes(format);
1868 int lane_size_in_bytes = GetPrintRegLaneSizeInBytes(format);
1884 PrintRegisterFormat format,
1894 int lane_size_in_bytes = GetPrintRegLaneSizeInBytes(format);
1896 PrintVRegistersForStructuredAccess(rt_code, reg_count, lane_mask, format);
1902 PrintRegisterFormat format,
1912 int lane_size_in_bytes = GetPrintRegLaneSizeInBytes(format);
1913 uint16_t lane_mask = GetPrintRegLaneMask(format);
1914 PrintVRegistersForStructuredAccess(rt_code, reg_count, lane_mask, format);
1921 // Scalar-format accesses are split into separate chunks, each of which uses a
1922 // simple format:
1946 PrintRegisterFormat format,
1958 // We're going to print the register in parts, so force a partial format.
1959 bool skip_inactive_chunks = (format & kPrintRegPartial) != 0;
1960 format = GetPrintRegPartial(format);
1962 int esize_in_bytes = GetPrintRegLaneSizeInBytes(format);
1968 pg.GetActiveMask<uint16_t>(q_index) & GetPrintRegLaneMask(format);
1975 format);
2005 // Scalar-format accesses are split into separate chunks, each of which uses a
2006 // simple format:
2046 PrintRegisterFormat format,
2048 VIXL_ASSERT(GetPrintRegLaneCount(format) == 1);
2052 PrintAccess(rt_code, format, "<-", address);
2056 PrintRegisterFormat format,
2059 int reg_size_in_bytes = GetPrintRegSizeInBytes(format);
2062 PrintRead(rt_code, format, address);
2069 VIXL_ASSERT(GetPrintRegLaneCount(format) == 1);
2073 PrintRegister(rt_code, format);
2084 PrintRegisterFormat format,
2086 VIXL_ASSERT(GetPrintRegLaneCount(format) == 1);
2088 PrintVAccess(rt_code, format, "<-", address);
2092 PrintRegisterFormat format,
2096 format = GetPrintRegPartial(format);
2097 VIXL_ASSERT(GetPrintRegLaneCount(format) == 1);
2101 PrintAccess(rt_code, format, "->", address);
2105 PrintRegisterFormat format,
2109 format = GetPrintRegPartial(format);
2112 VIXL_ASSERT(GetPrintRegLaneCount(format) == 1);
2113 PrintVAccess(rt_code, format, "->", address);
4642 PrintRegisterFormat format = GetPrintRegisterFormatForSize(element_size);
4643 LogRead(rs, format, address);
4644 LogRead(rs + 1, format, address2);
4647 LogWrite(rt, format, address);
4648 LogWrite(rt + 1, format, address2);
4853 PrintRegisterFormat format = GetPrintRegisterFormatForSize(reg_size);
4854 LogExtendingRead(rt, format, element_size, address);
4856 LogExtendingRead(rt2, format, element_size, address + element_size);
4918 PrintRegisterFormat format =
4920 LogWrite(rt, format, address);
4922 LogWrite(rt2, format, address + element_size);
4992 PrintRegisterFormat format = GetPrintRegisterFormatForSize(register_size);
4993 LogExtendingRead(rt, format, element_size, address);
4996 format = GetPrintRegisterFormatForSize(element_size);
4997 LogWrite(rs, format, address);
5028 PrintRegisterFormat format = GetPrintRegisterFormatForSize(element_size);
5029 LogRead(rt, format, address);
5030 LogWrite(rs, format, address);
5065 // clang-format off
5111 // clang-format on
8106 // Promote the format to Q-sized vector format before the duplication.
8645 // Find the format and immediate value
11818 VectorFormat format = instr->GetSVEVectorFormat();
11826 if ((format == kFormatVnB) && (shift == 8)) {
11829 dup_immediate(format, zd, imm);
14500 // work around the problem, we pick apart the format string, and print one
14501 // format placeholder at a time.
14503 // Allocate space for the format string. We take a copy, so we can modify it.
14509 char* const format = allocator_.New<char[]>(length + arg_count);
14510 // A list of chunks, each with exactly one format placeholder.
14513 // Copy the format string and search for format placeholders.
14515 char* format_scratch = format;
14524 // Chunks after the first are passed as format strings to printf, so we
14546 // 'format' contains no format placeholders and should be printed literally.
14547 int result = printf("%s", format);
14548 int pcs_r = 1; // Start at x1. x0 holds the format string.
14590 allocator_.DeleteArray(format);