private static LocationDescriptor createDataMemberLocationDescriptor(
			OperandFieldLocation location, Address address) {

		// Note: we don't support data types on external addresses; this could change in the future
		if (address.isExternalAddress()) {
			return null;
		}

		Program program = location.getProgram();
		Data outermostData = getDataContainingAddress(program, address);
		if (outermostData == null) {
			// no data
			return null;
		}

		String fieldPath = getFieldPath(location);
		if (!fieldPath.contains(".")) {

			// no field reference, so don't create a structure member reference, but just a generic
			// data type reference
			DataType type = outermostData.getDataType();
			if (type == DataType.DEFAULT || Undefined.isUndefined(type)) {
				// nobody wants to search for undefined usage; too many (this is the case where the
				// user is not on an actual data type)
				return null;
			}

			LocationDescriptor dtDescriptor =
				createGenericDataTypeLocationDescriptor(program, type, fieldPath);
			return dtDescriptor;
		}

		String fieldName = getFieldName(location);
		Address parentAddress = outermostData.getMinAddress();
		int componentAddress = (int) address.subtract(parentAddress);
		Data subData = outermostData.getComponentContaining(componentAddress);
		if (subData != null) {

			int[] componentPath = subData.getComponentPath();
			FieldNameFieldLocation fieldLocation =
				new FieldNameFieldLocation(program, address, componentPath, fieldName, 0);
			LocationDescriptor descriptor =
				createSubDataMemberLocationDescriptor(program, address, fieldLocation, subData);
			return descriptor;
		}

		//
		// No sub-data.  See if we know how to handle the containing data.
		//
		DataType dt = outermostData.getDataType();
		if (dt instanceof Union) {
			AddressFieldLocation addressLocation =
				new AddressFieldLocation(program, address, new int[] { 0 }, address.toString(), 0);
			return new UnionLocationDescriptor(addressLocation, program);
		}

		return null;
	}
HACK: We are watching for a condition where the goto service can send out goto locations
that are not correct for a program, but can still be handled by that program.
<p>
As an example, the goto service may be trying to handle a
FunctionSignatureFieldLocation.  Further, let's
say that the address for that location is 100.  Now suppose that program 'foo' has an
address '100', but does not have a function at that location.  'foo' will decide  to
handle the location event regardless.  In this scenario, where a program handles a location
that is not correct (a function location where there is no function), the
LocationDescriptor objects will not work and will throw exceptions.

see SCR 4642
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/navigation/locationreferences/ReferenceUtils.java