private void followInstructionBack(Stack<CodeUnit> instructionStack, AddressSet flowAddressSet,
			Instruction currentInstr) {

		// Don't follow if not following into (or back from) functions, and instruction is at a function.
		if (!followIntoFunction) {
			Symbol primarySymbol = currentInstr.getPrimarySymbol();
			if (primarySymbol.getSymbolType() == SymbolType.FUNCTION) {
				return;
			}
		}

		Address fromAddress = null; // The from address

		/*************************
		 * Follow Flows Backward *
		 *************************/
		Address[] flowFromAddresses = getFlowsAndPointersToInstruction(currentInstr);
		for (int index = 0; (flowFromAddresses != null) &&
			(index < flowFromAddresses.length); index++) {
			fromAddress = flowFromAddresses[index];
			if (fromAddress != null) {
				CodeUnit nextCodeUnit = program.getListing().getCodeUnitContaining(fromAddress);
				if (nextCodeUnit != null) {
					if (nextCodeUnit instanceof Data) {
						Data data = (Data) nextCodeUnit;
						Address minAddress = data.getMinAddress();
						int offset = (int) fromAddress.subtract(minAddress);
						Data primitive = data.getPrimitiveAt(offset);
						if ((primitive != null) && primitive.isPointer()) {
							// If we flowed from an instruction back to a pointer then see if
							// we should continue to flow back further from that data.
							followDataBack(instructionStack, flowAddressSet, (Data) nextCodeUnit,
								fromAddress);
						}
					}
					else {
						instructionStack.push(nextCodeUnit);
					}
				}
			}
		}

		// fallFrom will get flows to beginning of delay slot instructions,
		// but need to catch any flows directly into delay slot instructions.
		getFlowsToPreceedingDelaySlots(currentInstr, instructionStack, flowAddressSet);

		/*********************
		 * Follow Fall From  *
		 *********************/
		// If we can fall through to here then get that instruction that fell through, add it to the
		// code unit stack so we can see if we can flow to it.
		fromAddress = currentInstr.getFallFrom(); // the address we fell from.

		if (fromAddress != null) {
			Instruction fromInstruction = program.getListing().getInstructionAt(fromAddress);
			if (fromInstruction != null) {
				instructionStack.push(fromInstruction);
			}
		}
	}
followInstructionBack follows the program's instruction flow and adds addresses
to the address set for the flow to the current instruction.
The plugin's properties indicate which flow types should be followed for
instruction code units.

@param instructionStack the instruction stack of instructions to flow to.
@param flowAddressSet the address set to add our addresses to.
@param currentInstr the Instruction object to flow to.
    Appropriate flows to this code unit will be traversed.
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/block/FollowFlow.java