private void processInstructionFlows(PseudoInstruction inst, InstructionBlock block) {
		// Process language specified flows only - following refs may result in context conflicts
		Address[] flowAddrs = inst.getFlows();
		FlowType flowType = inst.getFlowType();
		Address instAddr = inst.getMinAddress();

		// if this is an indirect call through a known address, put the address on flows to be checked for no-return
		//
		if (flowAddrs.length == 0 && flowType.isCall()) {
			checkForIndirectCallFlow(inst, flowType);
		}

		//Reference refsFrom[] = inst.getReferencesFrom();
		for (Address flowAddr : flowAddrs) {

			//check to see if function does not return...
			if (flowAddrs.length == 1 && flowType.isCall() && isNoReturnCall(inst, flowAddr)) {
				// do the override magic
				inst.setFlowOverride(FlowOverride.CALL_RETURN);
				continue;
			}

			if (flowAddr.getOffset() % instAlignment != 0) {
				block.setInstructionError(InstructionErrorType.FLOW_ALIGNMENT, instAddr, null, null,
					"Flow destination address " + flowAddr + " from " + instAddr + " violates " +
						instAlignment + "-byte instruction alignment");
			}
			else {
				disassemblerContext.copyToFutureFlowState(flowAddr);
				if (flowType.isCall()) {
					// queuing of call flow is deferred until after block has been
					// added to program - block used to hold onto it for later
					block.addBlockFlow(new InstructionBlockFlow(flowAddr, instAddr,
						InstructionBlockFlow.Type.CALL));
				}
				else {
					InstructionBlockFlow branchFlow = new InstructionBlockFlow(flowAddr, instAddr,
						InstructionBlockFlow.Type.BRANCH);
					if (disassemblerQueue != null) {
						disassemblerQueue.queueCurrentFlow(branchFlow);
					}
					block.addBlockFlow(branchFlow);
					block.addBranchFlow(flowAddr);
				}
			}
		}
	}
Process a new instruction which has just been parsed.  This method is responsible for
adding the instruction to the current block as well as any delay-slotted instructions.
This method may be overridden and the instruction re-parsed if necessary. 

@param inst instruction to process
@param blockMemBuffer buffer to get bytes
@param block current block of instructions
@param instructionSet address set of current instructions in block
@return instruction fallthrough address or null if no fallthrough
@throws InsufficientBytesException if a memory error occurs during instruction processing 
@throws UnknownInstructionException if an error occurs during a modified re-parse of
the instruction.
@throws AddressOverflowException if address goes out of address space
@throws NestedDelaySlotException if delay slot found in a delay slot
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/disassemble/Disassembler.java