Lines Matching refs:data
67 Label data;
70 masm->Adr(temp, &data);
75 masm->bind(&data);
295 uint8_t data[kQRegSizeInBytes];
297 data[i] = 42 + i;
299 __ Mov(x10, reinterpret_cast<uintptr_t>(data));
5623 // Broadcasting an data within the input array.
5632 // Selecting an data beyond the input array.
6850 uint8_t* data = new uint8_t[data_size];
6851 memset(data, 0, data_size);
6854 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[data_size / 2]));
6912 ASSERT_EQUAL_MEMORY(expected, data, data_size, middle - expected);
6926 delete[] data;
6941 uint8_t* data = new uint8_t[data_size];
6942 memset(data, 0, data_size);
6945 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[data_size / 2]));
7011 ASSERT_EQUAL_MEMORY(expected, data, data_size, middle - expected);
7024 delete[] data;
7028 static void MemoryWrite(uint8_t* base, int64_t offset, int64_t index, T data) {
7029 memcpy(base + offset + (index * sizeof(data)), &data, sizeof(data));
7042 uint8_t* data = new uint8_t[data_size];
7043 memset(data, 0, data_size);
7046 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[data_size / 2]));
7213 ASSERT_EQUAL_MEMORY(expected, data, data_size, middle - expected);
7230 delete[] data;
7243 uint8_t* data = new uint8_t[data_size];
7244 memset(data, 0, data_size);
7247 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[data_size / 2]));
7381 ASSERT_EQUAL_MEMORY(expected, data, data_size, middle - expected);
7403 delete[] data;
7415 uint8_t* data = new uint8_t[data_size];
7416 memset(data, 0, data_size);
7419 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[data_size / 2]));
7553 ASSERT_EQUAL_MEMORY(expected, data, data_size, middle - expected);
7575 delete[] data;
7588 uint8_t* data = new uint8_t[data_size];
7589 memset(data, 0, data_size);
7592 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[data_size / 2]));
7756 ASSERT_EQUAL_MEMORY(expected, data, data_size, middle - expected);
7782 delete[] data;
7794 uint8_t* data = new uint8_t[data_size];
7795 memset(data, 0, data_size);
7798 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[data_size / 2]));
7969 ASSERT_EQUAL_MEMORY(expected, data, data_size, middle - expected);
7995 delete[] data;
8008 uint8_t* data = new uint8_t[data_size];
8009 memset(data, 0, data_size);
8012 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[data_size / 2]));
8216 ASSERT_EQUAL_MEMORY(expected, data, data_size, middle - expected);
8246 delete[] data;
8258 uint8_t* data = new uint8_t[data_size];
8259 memset(data, 0, data_size);
8262 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[data_size / 2]));
8477 ASSERT_EQUAL_MEMORY(expected, data, data_size, middle - expected);
8507 delete[] data;
8696 // Fill the input buffer with arbitrary data. Meanwhile, assign random offsets
8709 // Fill a buffer with arbitrary data.
8805 uintptr_t data,
8831 // `data + page_size`, so this value should not exceed that value. However,
8858 __ Mov(x20, data);
8906 base_address = data;
8912 base_address = data + (2 * page_size);
8970 uintptr_t expected_limit = data + page_size;
8994 uintptr_t data = reinterpret_cast<uintptr_t>(mmap(NULL,
9000 mprotect(reinterpret_cast<void*>(data + page_size), page_size, PROT_NONE);
9002 // Fill the accessible page with arbitrary data.
9006 memcpy(reinterpret_cast<void*>(data + i), &byte, 1);
9011 data,
9035 data,
9068 munmap(reinterpret_cast<void*>(data), page_size * 2);
9072 uintptr_t data) {
9075 data,
9100 uintptr_t data) {
9103 data,
9139 Test* config, uintptr_t data) {
9143 data,
9179 Test* config, uintptr_t data) {
9183 data,
9229 uintptr_t data) {
9232 data,
9263 uintptr_t data) {
9266 data,
9309 uintptr_t data = reinterpret_cast<uintptr_t>(mmap(NULL,
9315 mprotect(reinterpret_cast<void*>(data + page_size), page_size, PROT_NONE);
9317 // Fill the accessible page with arbitrary data.
9321 memcpy(reinterpret_cast<void*>(data + i), &byte, 1);
9324 sve_ldff1_scalar_plus_vector_32_scaled_offset(config, data);
9325 sve_ldff1_scalar_plus_vector_32_unscaled_offset(config, data);
9326 sve_ldff1_scalar_plus_vector_32_unpacked_scaled_offset(config, data);
9327 sve_ldff1_scalar_plus_vector_32_unpacked_unscaled_offset(config, data);
9328 sve_ldff1_scalar_plus_vector_64_scaled_offset(config, data);
9329 sve_ldff1_scalar_plus_vector_64_unscaled_offset(config, data);
9331 munmap(reinterpret_cast<void*>(data), page_size * 2);
9343 // Allocate two pages, fill them with data, then mprotect the second one to
9345 uintptr_t data = reinterpret_cast<uintptr_t>(mmap(NULL,
9352 // Fill the pages with arbitrary data.
9356 memcpy(reinterpret_cast<void*>(data + i), &byte, 1);
9359 mprotect(reinterpret_cast<void*>(data + page_size), page_size, PROT_NONE);
9366 __ Mov(x0, data + page_size - (kQRegSizeInBytes / kBRegSizeInBytes) / 2);
9410 __ Mov(x0, data + page_size - (kQRegSizeInBytes / kSRegSizeInBytes) / 2);
9418 __ Mov(x0, data + page_size - (kQRegSizeInBytes / kHRegSizeInBytes) / 2);
9438 munmap(reinterpret_cast<void*>(data), page_size * 2);
9449 uintptr_t data = reinterpret_cast<uintptr_t>(mmap(NULL,
9455 uintptr_t middle = data + page_size;
9456 // Fill the accessible page with arbitrary data.
9645 uintptr_t data = reinterpret_cast<uintptr_t>(mmap(NULL,
9651 uintptr_t middle = data + page_size;
9652 // Fill the accessible page with arbitrary data.
9842 uint64_t data = reinterpret_cast<uintptr_t>(malloc(buffer_size));
9843 // Fill the buffer with arbitrary data. Meanwhile, create the random addresses
9845 BufferFillingHelper(data,
9867 addresses[i] = data + offsets[i];
9882 __ Mov(x0, data);
9905 // Test the data correctness in which the data gather load from different
9926 free(reinterpret_cast<void*>(data));
9951 uint64_t data = reinterpret_cast<uintptr_t>(malloc(buffer_size));
9952 BufferFillingHelper(data,
9993 (masm.*sve_ld1)(zt_offsets, pg, SVEMemOperand(zn, data));
10020 free(reinterpret_cast<void*>(data));
10340 uint8_t* data = new uint8_t[data_size];
10342 data[i] = i & 0xff;
10346 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[data_size / 2]));
10400 uint8_t* data = new uint8_t[data_size];
10403 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[data_size / 2]));
10457 uint8_t* data = new uint8_t[data_size];
10459 data[i] = i & 0xff;
10463 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[data_size / 2]));
10549 uint8_t* data = new uint8_t[data_size];
10553 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[data_size - 16]));
10571 // Reload the stored data, and build a reference for comparison. The reference
10614 __ Mov(x0, reinterpret_cast<uintptr_t>(data));
10648 uint8_t* data = new uint8_t[data_size];
10649 memset(data, 0, data_size);
10664 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[data_size / 2]));
10745 delete[] data;
15914 // Unpack the data from the array of struct into individual arrays that can
18513 uint64_t data = reinterpret_cast<uintptr_t>(malloc(buffer_size));
18514 BufferFillingHelper(data,
18538 __ Mov(x2, data);
18544 uint64_t address = data + enablable_offset;
18572 __ Mov(x3, data + offsets[i]);
18586 free(reinterpret_cast<void*>(data));
18932 uint8_t* data = new uint8_t[data_size];
18934 data[i] = i & 0xff;
18938 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[data_size / 2]));
18993 uint8_t* data = new uint8_t[data_size];
18996 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[data_size / 2]));
20084 uint8_t* data = new uint8_t[data_size];
20086 data[i] = i & 0xff;
20091 __ Mov(x0, reinterpret_cast<uintptr_t>(&data[7 + data_size / 2]));