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
}
