func (this *Fetcher) fetchInstructions(op *operation.Operation, bytes []byte, input channel.Channel) ([]*operation.Operation, error) { initialAddress := op.Address() totalInstructions := len(bytes) / consts.BYTES_PER_WORD ops := []*operation.Operation{} // Analyze each instruction loaded for i := 0; i < totalInstructions; i += 1 { data := bytes[i*consts.BYTES_PER_WORD : (i+1)*consts.BYTES_PER_WORD] // Check program reach end if this.Processor().ReachedEnd(data) { this.processor.Finish() return ops, nil } // Do fetch once a new address is received msg := fmt.Sprintf(" => [FE%d][%03d]: INS[%#04X] = %#04X", this.Index(), this.Processor().InstructionsFetchedCounter(), op.Address(), data) value, ok := this.Processor().InstructionsMap()[op.Address()] if ok { msg = fmt.Sprintf("%s // %s", msg, strings.TrimSpace(strings.Split(value, "=>")[1])) } logger.Collect(msg) // Log event this.Processor().LogInstructionFetched(op.Address()) // Update data into operation and add to array for post-events op.SetWord([]byte{data[0], data[1], data[2], data[3]}) // Add operation to be sent to decode channel ops = append(ops, op) // Do pre-decode needsWait, instruction := this.BranchPredictor().PreDecodeInstruction(op.Address()) // If is not pipelined than wait instruction to finish if !this.Processor().Config().Pipelined() { go func() { address, _, err := this.BranchPredictor().GetNextAddress(op.Address(), instruction, true) newOp := operation.New(this.Processor().InstructionsFetchedCounter(), address) if err == nil { input.Add(newOp) } }() return ops, nil } // Add next instruction for fetching (as many instructions as it supports per cycle) if needsWait { logger.Collect(" => [FE%d][%03d]: Wait detected, no fetching more instructions this cycle", this.Index(), this.Processor().InstructionsFetchedCounter()-1) // Add next instruction in a go routine as it need to be stalled go func() { address, _, err := this.BranchPredictor().GetNextAddress(op.Address(), instruction, false) newOp := operation.New(this.Processor().InstructionsFetchedCounter(), address) if err == nil { input.Add(newOp) } }() return ops, nil } else { address, predicted, err := this.BranchPredictor().GetNextAddress(op.Address(), instruction, false) // Set current operation added to be decoded the predicted address if predicted { ops[len(ops)-1].SetNextPredictedAddress(address) } // Create new operation object op = operation.New(this.Processor().InstructionsFetchedCounter(), address) // If is the last instruction from the package or the predicted address is outside of the address package if err == nil && (i >= totalInstructions-1 || initialAddress+(uint32(i+1)*consts.BYTES_PER_WORD) != op.Address()) { input.Add(op) return ops, nil } } } return ops, nil }