private void populateStubStruct_worker(DWARFDataType ddt, StructureDataType structure,
			DIEAggregate diea, DWARFTag childTagType) throws IOException, DWARFExpressionException {

		for (DebugInfoEntry childEntry : diea.getChildren(childTagType)) {

			DIEAggregate childDIEA = prog.getAggregate(childEntry);
			// skip static member vars as they do not have storage in the structure
			if (childDIEA.hasAttribute(DW_AT_external)) {
				continue;
			}

			int bitSize = childDIEA.parseInt(DW_AT_bit_size, -1);
			boolean isBitField = bitSize != -1;

			DWARFDataType childDT = getDataType(childDIEA.getTypeRef(), null);
			if (childDT == null) {
				Msg.error(this,
					"Failed to get data type for struct field: " + childDIEA.getHexOffset());
				continue;
			}
			DataType dt = fixupDataTypeInconsistencies(childDT);

			String memberName = childDIEA.getName();

			// construct a name for the member if needed using context information
			// instead of relying on DNI
			if (memberName == null) {
				// If the member is an inheritance type, then set the name
				// to be the name of the data type
				if (childDIEA.getTag() == DW_TAG_inheritance) {
					memberName = "super_" + dt.getName();
				}
				else {
					memberName = "field_" + structure.getNumDefinedComponents();
				}
			}

			boolean hasMemberOffset =
				childDIEA.hasAttribute(DW_AT_data_member_location);

			int memberOffset = 0;
			if (hasMemberOffset) {
				try {
					memberOffset = childDIEA.parseDataMemberOffset(DW_AT_data_member_location, 0);
				}
				catch (DWARFExpressionException e) {
					DWARFUtil.appendDescription(structure, memberDesc("Missing member",
						"failed to parse location", memberName, dt, -1, bitSize, -1), "\n");
					continue;
				}
			}

			//if (childDT.getPathName().equals(structure.getPathName()) && childDT != structure) {
			// The child we are adding has the exact same fullpath as us.
			// This can happen when DWARF namespace info gets squished and two types
			// originally from different namespaces with the same name end up in the root namespace.
			// Even though we aren't doing anything yet, with more data or examples
			// we will probably decide that this needs to be addressed in the future.
			// TODO: rename parent struct here.  use .conflict or _basetype?
			//}

			if (isBitField) {
				if (!BitFieldDataType.isValidBaseDataType(dt)) {
					DWARFUtil.appendDescription(structure,
						memberDesc("Missing member", "Bad data type for bitfield: " + dt.getName(),
							memberName, dt, -1, bitSize, -1),
						"\n");
					continue;
				}

				int containerLen;
				if (hasMemberOffset) {
					int byteSize = childDIEA.parseInt(DW_AT_byte_size, -1);
					containerLen = byteSize <= 0 ? dt.getLength() : byteSize;
				}
				else {
					containerLen = structure.getLength();
				}
				int containerBitLen = containerLen * 8;

				int bitOffset = childDIEA.parseInt(DW_AT_data_bit_offset, -1);
				int ghidraBitOffset;
				if (bitOffset == -1) {
					// try to fall back to previous dwarf version's bit_offset attribute that has slightly different info
					bitOffset = childDIEA.parseInt(DW_AT_bit_offset, -1);

					// convert DWARF bit offset value to Ghidra bit offset
					ghidraBitOffset = containerBitLen - bitOffset - bitSize;
				}
				else {
					// convert DWARF bit offset to Ghidra bit offset
					ghidraBitOffset = bitOffset - (memberOffset * 8);
					boolean isBE = prog.getGhidraProgram().getMemory().isBigEndian();
					if (isBE) {
						ghidraBitOffset = containerBitLen - ghidraBitOffset - bitSize;
					}
				}

				if (bitOffset < 0 || ghidraBitOffset < 0 || ghidraBitOffset >= containerBitLen) {
					DWARFUtil.appendDescription(structure, memberDesc("Missing member",
						"bad bitOffset", memberName, dt, memberOffset, bitSize, bitOffset),
						"\n");
					continue;
				}

				try {
					// TODO: need safety checks here to make sure that using insertAt() doesn't
					// modify the struct
					structure.insertBitFieldAt(memberOffset, containerLen, ghidraBitOffset,
						dt, bitSize, memberName, null);
				}
				catch (InvalidDataTypeException e) {
					Msg.error(this,
						"Unable to add member " + memberName + " to structure " +
							structure.getDataTypePath() + "[DWARF DIE " + diea.getHexOffset() +
							"], skipping: " + e.getMessage());
					DWARFUtil.appendDescription(structure,
						memberDesc("Missing member ", "Failed to add bitfield", memberName, dt,
							memberOffset, bitSize, bitOffset),
						"\n");
				}
			}
			else {
				String memberComment = null;
				boolean isDynamicSizedType =
					(dt instanceof Dynamic || dt instanceof FactoryDataType);
				if (isDynamicSizedType) {
					memberComment = "Unsupported dynamic size data type: " + dt;
					dt = Undefined.getUndefinedDataType(1);
				}
				int childLength = getUnpaddedDataTypeLength(dt);
				if (memberOffset + childLength > structure.getLength()) {
					DWARFUtil.appendDescription(structure, memberDesc("Missing member",
						"exceeds parent struct len", memberName, dt, memberOffset, -1, -1),
						"\n");

					continue;
				}

				try {
					DataTypeComponent dtc;
					if (DataTypeComponent.usesZeroLengthComponent(dt)) {
						if (!isUndefinedOrZeroLenAtOffset(structure, memberOffset)) {
							DWARFUtil.appendDescription(structure, memberDesc("Missing member",
								"conflicting member at same offset", memberName, dt,
								memberOffset, -1, -1), "\n");
							continue;
						}
						// use insertAt for zero len members to allow multiple at same offset
						dtc =
							structure.insertAtOffset(memberOffset, dt, 0, memberName,
								memberComment);
					}
					else {
						int ordinalToReplace = getUndefinedOrdinalAt(structure, memberOffset);
						if (ordinalToReplace == -1) {
							DataTypeComponent existingDTC =
								structure.getComponentContaining(memberOffset);
							if (existingDTC != null) {
								DWARFUtil.appendDescription(structure,
									memberDesc("Missing member",
										"conflict with " + existingDTC.getFieldName(),
										memberName, dt, memberOffset, -1, -1),
									"\n");
							}
							continue;
						}
						dtc = structure.replace(ordinalToReplace, dt, childLength, memberName,
							memberComment);
					}
					// struct.replaceAtOffset() and insertAtOffset() clones the childDT, which will mess up our
					// identity based mapping in currentImplDataTypeToDDT.
					// Update the mapping to prevent that.
					updateMapping(dt, dtc.getDataType());
				}
				catch (IllegalArgumentException exc) {
					Msg.error(this,
						"Unable to add member " + memberName + " to structure " +
							structure.getDataTypePath() + "[DWARF DIE " + diea.getHexOffset() +
							"], skipping: " + exc.getMessage());
					DWARFUtil.appendDescription(structure, memberDesc("Missing member ", "",
						memberName, dt, memberOffset, -1, -1), "\n");
				}
			}
		}
	}
Returns true if the DWARF struct is larger than Ghidra allows (ie. bigger than MAX_INT).

@param structSize long int size of the DWARF struct
@return true if bigger than Ghidra can handle
Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/dwarf/DWARFDataTypeImporter.java