Lines Matching defs:item
343 ALOGE("Unknown map item type %04x", mapType);
350 * Helper for swapMap(), which indicates if an item type should appear
375 DexMapItem* item = pMap->list;
386 CHECK_LIST_SIZE(item, count, sizeOfItem);
389 SWAP_FIELD2(item->type);
390 SWAP_FIELD2(item->unused);
391 SWAP_FIELD4(item->size);
392 SWAP_OFFSET4(item->offset);
396 } else if (lastOffset >= item->offset) {
397 ALOGE("Out-of-order map item: %#x then %#x",
398 lastOffset, item->offset);
402 if (item->offset >= state->pHeader->fileSize) {
403 ALOGE("Map item after end of file: %x, size %#x",
404 item->offset, state->pHeader->fileSize);
408 if (isDataSectionType(item->type)) {
409 u4 icount = item->size;
426 u4 bit = mapTypeToBitMask(item->type);
433 ALOGE("Duplicate map section of type %#x", item->type);
437 if (item->type == kDexTypeCallSiteIdItem) {
438 state->pCallSiteIds = item;
439 } else if (item->type == kDexTypeMethodHandleItem) {
440 state->pMethodHandleItems = item;
444 lastOffset = item->offset;
445 item++;
530 /* Perform byte-swapping and intra-item verification on string_id_item. */
532 DexStringId* item = (DexStringId*) ptr;
534 CHECK_PTR_RANGE(item, item + 1);
535 SWAP_OFFSET4(item->stringDataOff);
537 return item + 1;
540 /* Perform cross-item verification of string_id_item. */
542 const DexStringId* item = (const DexStringId*) ptr;
545 item->stringDataOff, kDexTypeStringDataItem)) {
553 const char* s1 = dexGetStringData(state->pDexFile, item);
560 return (void*) (item + 1);
563 /* Perform byte-swapping and intra-item verification on type_id_item. */
565 DexTypeId* item = (DexTypeId*) ptr;
567 CHECK_PTR_RANGE(item, item + 1);
568 SWAP_INDEX4(item->descriptorIdx, state->pHeader->stringIdsSize);
570 return item + 1;
573 /* Perform cross-item verification of type_id_item. */
575 const DexTypeId* item = (const DexTypeId*) ptr;
577 dexStringById(state->pDexFile, item->descriptorIdx);
587 if (item0->descriptorIdx >= item->descriptorIdx) {
589 item0->descriptorIdx, item->descriptorIdx);
594 return (void*) (item + 1);
597 /* Perform byte-swapping and intra-item verification on proto_id_item. */
599 DexProtoId* item = (DexProtoId*) ptr;
601 CHECK_PTR_RANGE(item, item + 1);
602 SWAP_INDEX4(item->shortyIdx, state->pHeader->stringIdsSize);
603 SWAP_INDEX4(item->returnTypeIdx, state->pHeader->typeIdsSize);
604 SWAP_OFFSET4(item->parametersOff);
606 return item + 1;
654 /* Perform cross-item verification of proto_id_item. */
656 const DexProtoId* item = (const DexProtoId*) ptr;
658 dexStringById(state->pDexFile, item->shortyIdx);
661 item->parametersOff, kDexTypeTypeList)) {
666 dexStringByTypeIdx(state->pDexFile, item->returnTypeIdx),
671 u4 protoIdx = item - state->pDexFile->pProtoIds;
705 if (item0->returnTypeIdx > item->returnTypeIdx) {
708 } else if (item0->returnTypeIdx == item->returnTypeIdx) {
744 return (void*) (item + 1);
747 /* Perform byte-swapping and intra-item verification on field_id_item. */
749 DexFieldId* item = (DexFieldId*) ptr;
751 CHECK_PTR_RANGE(item, item + 1);
752 SWAP_INDEX2(item->classIdx, state->pHeader->typeIdsSize);
753 SWAP_INDEX2(item->typeIdx, state->pHeader->typeIdsSize);
754 SWAP_INDEX4(item->nameIdx, state->pHeader->stringIdsSize);
756 return item + 1;
759 /* Perform cross-item verification of field_id_item. */
761 const DexFieldId* item = (const DexFieldId*) ptr;
764 s = dexStringByTypeIdx(state->pDexFile, item->classIdx);
770 s = dexStringByTypeIdx(state->pDexFile, item->typeIdx);
776 s = dexStringById(state->pDexFile, item->nameIdx);
788 if (item0->classIdx > item->classIdx) {
791 } else if (item0->classIdx < item->classIdx) {
796 if (item0->nameIdx > item->nameIdx) {
799 } else if (item0->nameIdx < item->nameIdx) {
805 if (item0->typeIdx >= item->typeIdx) {
816 return (void*) (item + 1);
819 /* Perform byte-swapping and intra-item verification on method_id_item. */
821 DexMethodId* item = (DexMethodId*) ptr;
823 CHECK_PTR_RANGE(item, item + 1);
824 SWAP_INDEX2(item->classIdx, state->pHeader->typeIdsSize);
825 SWAP_INDEX2(item->protoIdx, state->pHeader->protoIdsSize);
826 SWAP_INDEX4(item->nameIdx, state->pHeader->stringIdsSize);
828 return item + 1;
831 /* Perform cross-item verification of method_id_item. */
833 const DexMethodId* item = (const DexMethodId*) ptr;
836 s = dexStringByTypeIdx(state->pDexFile, item->classIdx);
842 s = dexStringById(state->pDexFile, item->nameIdx);
854 if (item0->classIdx > item->classIdx) {
857 } else if (item0->classIdx < item->classIdx) {
862 if (item0->nameIdx > item->nameIdx) {
865 } else if (item0->nameIdx < item->nameIdx) {
871 if (item0->protoIdx >= item->protoIdx) {
882 return (void*) (item + 1);
885 /* Perform byte-swapping and intra-item verification on class_def_item. */
887 DexClassDef* item = (DexClassDef*) ptr;
889 CHECK_PTR_RANGE(item, item + 1);
890 SWAP_INDEX4(item->classIdx, state->pHeader->typeIdsSize);
891 SWAP_FIELD4(item->accessFlags);
892 SWAP_INDEX4_OR_NOINDEX(item->superclassIdx, state->pHeader->typeIdsSize);
893 SWAP_OFFSET4(item->interfacesOff);
894 SWAP_INDEX4_OR_NOINDEX(item->sourceFileIdx, state->pHeader->stringIdsSize);
895 SWAP_OFFSET4(item->annotationsOff);
896 SWAP_OFFSET4(item->classDataOff);
898 if ((item->accessFlags & ~ACC_CLASS_MASK) != 0) {
900 ALOGV("Bogus class access flags %x", item->accessFlags);
901 item->accessFlags &= ACC_CLASS_MASK;
904 return item + 1;
957 /* Perform cross-item verification of class_def_item. */
959 const DexClassDef* item = (const DexClassDef*) ptr;
960 u4 classIdx = item->classIdx;
975 item->interfacesOff, kDexTypeTypeList)
977 item->annotationsOff, kDexTypeAnnotationsDirectoryItem)
979 item->classDataOff, kDexTypeClassDataItem)
981 item->staticValuesOff, kDexTypeEncodedArrayItem);
987 if (item->superclassIdx != kDexNoIndex) {
988 descriptor = dexStringByTypeIdx(state->pDexFile, item->superclassIdx);
996 dexGetInterfacesList(state->pDexFile, item);
1035 if (!verifyClassDataIsForDef(state, item->classDataOff, item->classIdx)) {
1040 if (!verifyAnnotationsDirectoryIsForDef(state, item->annotationsOff,
1041 item->classIdx)) {
1046 return (void*) (item + 1);
1049 /* Perform cross-item verification of call_site_id. */
1051 const DexCallSiteId* item = (const DexCallSiteId*) ptr;
1056 if (item->callSiteOff < state->pHeader->dataOff ||
1057 item->callSiteOff >= state->pHeader->dataOff + state->pHeader->dataSize) {
1058 ALOGE("Bad call site offset: %u", item->callSiteOff);
1061 return (void*) (item + 1);
1064 /* Perform cross-item verification of method_handle_item. */
1066 const DexMethodHandleItem* item = (const DexMethodHandleItem*) ptr;
1071 if (item->methodHandleType > (u2) MethodHandleType::INVOKE_INTERFACE) {
1072 ALOGE("Unknown method handle type: %u", item->methodHandleType);
1075 switch ((MethodHandleType) item->methodHandleType) {
1080 if (item->fieldOrMethodIdx >= state->pHeader->fieldIdsSize) {
1081 ALOGE("Method handle has invalid field id: %u\n", item->fieldOrMethodIdx);
1090 if (item->fieldOrMethodIdx >= state->pHeader->methodIdsSize) {
1091 ALOGE("Method handle has invalid method id: %u\n", item->fieldOrMethodIdx);
1096 return (void*) (item + 1);
1100 * byte-swapping and intra-item verification on an
1103 DexFieldAnnotationsItem* item = (DexFieldAnnotationsItem*) addr;
1108 CHECK_LIST_SIZE(item, count, sizeOfItem);
1111 SWAP_INDEX4(item->fieldIdx, state->pHeader->fieldIdsSize);
1112 SWAP_OFFSET4(item->annotationsOff);
1116 } else if (lastIdx >= item->fieldIdx) {
1118 item->fieldIdx);
1122 lastIdx = item->fieldIdx;
1123 item++;
1126 return (u1*) item;
1130 * byte-swapping and intra-item verification on an
1133 DexMethodAnnotationsItem* item = (DexMethodAnnotationsItem*) addr;
1138 CHECK_LIST_SIZE(item, count, sizeOfItem);
1141 SWAP_INDEX4(item->methodIdx, state->pHeader->methodIdsSize);
1142 SWAP_OFFSET4(item->annotationsOff);
1146 } else if (lastIdx >= item->methodIdx) {
1148 item->methodIdx);
1152 lastIdx = item->methodIdx;
1153 item++;
1156 return (u1*) item;
1160 * byte-swapping and intra-item verification on an
1164 DexParameterAnnotationsItem* item = (DexParameterAnnotationsItem*) addr;
1169 CHECK_LIST_SIZE(item, count, sizeOfItem);
1172 SWAP_INDEX4(item->methodIdx, state->pHeader->methodIdsSize);
1173 SWAP_OFFSET4(item->annotationsOff);
1177 } else if (lastIdx >= item->methodIdx) {
1179 item->methodIdx);
1183 lastIdx = item->methodIdx;
1184 item++;
1187 return (u1*) item;
1190 /* Perform byte-swapping and intra-item verification on
1193 DexAnnotationsDirectoryItem* item = (DexAnnotationsDirectoryItem*) ptr;
1195 CHECK_PTR_RANGE(item, item + 1);
1196 SWAP_OFFSET4(item->classAnnotationsOff);
1197 SWAP_FIELD4(item->fieldsSize);
1198 SWAP_FIELD4(item->methodsSize);
1199 SWAP_FIELD4(item->parametersSize);
1201 u1* addr = (u1*) (item + 1);
1203 if (item->fieldsSize != 0) {
1204 addr = swapFieldAnnotations(state, item->fieldsSize, addr);
1210 if (item->methodsSize != 0) {
1211 addr = swapMethodAnnotations(state, item->methodsSize, addr);
1217 if (item->parametersSize != 0) {
1218 addr = swapParameterAnnotations(state, item->parametersSize, addr);
1228 DexCallSiteId* item = (DexCallSiteId*) ptr;
1230 CHECK_PTR_RANGE(item, item + 1);
1231 SWAP_OFFSET4(item->callSiteOff);
1233 return (item + 1);
1237 DexMethodHandleItem* item = (DexMethodHandleItem*) ptr;
1239 CHECK_PTR_RANGE(item, item + 1);
1240 SWAP_FIELD2(item->methodHandleType);
1241 SWAP_FIELD2(item->fieldOrMethodIdx);
1243 return (item + 1);
1251 const DexFieldAnnotationsItem* item = (DexFieldAnnotationsItem*) addr;
1254 if (!verifyFieldDefiner(state, definingClass, item->fieldIdx)) {
1257 if (!dexDataMapVerify(state->pDataMap, item->annotationsOff,
1261 item++;
1264 return (const u1*) item;
1271 const DexMethodAnnotationsItem* item = (DexMethodAnnotationsItem*) addr;
1274 if (!verifyMethodDefiner(state, definingClass, item->methodIdx)) {
1277 if (!dexDataMapVerify(state->pDataMap, item->annotationsOff,
1281 item++;
1284 return (const u1*) item;
1291 const DexParameterAnnotationsItem* item =
1295 if (!verifyMethodDefiner(state, definingClass, item->methodIdx)) {
1298 if (!dexDataMapVerify(state->pDataMap, item->annotationsOff,
1302 item++;
1305 return (const u1*) item;
1310 * the definer of the first item in the data. */
1340 /* Perform cross-item verification of annotations_directory_item. */
1343 const DexAnnotationsDirectoryItem* item = (const DexAnnotationsDirectoryItem*) ptr;
1344 u4 definingClass = findFirstAnnotationsDirectoryDefiner(state, item);
1347 item->classAnnotationsOff, kDexTypeAnnotationSetItem)) {
1351 const u1* addr = (const u1*) (item + 1);
1353 if (item->fieldsSize != 0) {
1354 addr = crossVerifyFieldAnnotations(state, item->fieldsSize, addr,
1361 if (item->methodsSize != 0) {
1362 addr = crossVerifyMethodAnnotations(state, item->methodsSize, addr,
1369 if (item->parametersSize != 0) {
1370 addr = crossVerifyParameterAnnotations(state, item->parametersSize,
1380 /* Perform byte-swapping and intra-item verification on type_list. */
1403 /* Perform byte-swapping and intra-item verification on
1407 DexAnnotationSetRefItem* item;
1413 item = list->list;
1416 CHECK_LIST_SIZE(item, count, sizeOfItem);
1419 SWAP_OFFSET4(item->annotationsOff);
1420 item++;
1423 return item;
1426 /* Perform cross-item verification of annotation_set_ref_list. */
1430 const DexAnnotationSetRefItem* item = list->list;
1435 item->annotationsOff, kDexTypeAnnotationSetItem)) {
1438 item++;
1441 return (void*) item;
1444 /* Perform byte-swapping and intra-item verification on
1448 u4* item;
1454 item = set->entries;
1457 CHECK_LIST_SIZE(item, count, sizeOfItem);
1460 SWAP_OFFSET4(*item);
1461 item++;
1464 return item;
1469 static u4 annotationItemTypeIdx(const DexAnnotationItem* item) {
1470 const u1* data = item->annotation;
1474 /* Perform cross-item verification of annotation_set_item. */
1622 /* Perform intra-item verification on class_data_item. */
1645 * of the first item in the data. */
1675 /* Perform cross-item verification of class_data_item. */
1876 /* Perform byte-swapping and intra-item verification on code_item. */
1878 DexCode* item = (DexCode*) ptr;
1882 CHECK_PTR_RANGE(item, item + 1);
1883 SWAP_FIELD2(item->registersSize);
1884 SWAP_FIELD2(item->insSize);
1885 SWAP_FIELD2(item->outsSize);
1886 SWAP_FIELD2(item->triesSize);
1887 SWAP_OFFSET4(item->debugInfoOff);
1888 SWAP_FIELD4(item->insnsSize);
1890 if (item->insSize > item->registersSize) {
1891 ALOGE("insSize (%u) > registersSize (%u)", item->insSize,
1892 item->registersSize);
1896 if ((item->outsSize > 5) && (item->outsSize > item->registersSize)) {
1904 ALOGE("outsSize (%u) > registersSize (%u)", item->outsSize,
1905 item->registersSize);
1909 count = item->insnsSize;
1910 insns = item->insns;
1920 if (item->triesSize == 0) {
1931 ptr = swapTriesAndCatches(state, item);
1937 /* Perform intra-item verification on string_data_item. */
2038 /* Perform intra-item verification on debug_info_item. */
2441 /* Perform intra-item verification on encoded_array_item. */
2446 /* Perform intra-item verification on annotation_item. */
2468 * Function to visit an individual top-level item type.
2508 ALOGE("Trouble with item %d @ offset %#x", i, offset);
2597 * does all possible intra-item verification, that is, verification
2599 * items. The intra-item limitation is because at the time an item is
2605 const DexMapItem* item = pMap->list;
2611 u4 sectionOffset = item->offset;
2612 u4 sectionCount = item->size;
2613 u2 type = item->type;
2769 ALOGE("Unknown map item type %04x", type);
2778 item++;
2785 * Perform cross-item verification on everything that needs it. This
2791 const DexMapItem* item = pMap->list;
2796 u4 sectionOffset = item->offset;
2797 u4 sectionCount = item->size;
2799 switch (item->type) {
2808 // There is no need for cross-item verification for these.
2880 ALOGE("Unknown map item type %04x", item->type);
2886 ALOGE("Cross-item verify of section type %04x failed",
2887 item->type);
2890 item++;