1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
// SPDX-License-Identifier: Apache-2.0
package chisel3.experimental.hierarchy
import scala.language.experimental.macros
import chisel3._
import chisel3.internal.BaseModule.{InstantiableClone, IsClone, ModuleClone}
import chisel3.internal.Builder
import chisel3.internal.sourceinfo.{InstanceTransform, SourceInfo}
import chisel3.experimental.{BaseModule, ExtModule}
import chisel3.internal.firrtl.{Component, DefBlackBox, DefModule, Port}
import firrtl.annotations.IsModule
import chisel3.internal.throwException
/** User-facing Instance type.
* Represents a unique instance of type [[A]] which are marked as @instantiable
* Can be created using Instance.apply method.
*
* @param underlying The internal representation of the instance, which may be either be directly the object, or a clone of an object
*/
final case class Instance[+A] private[chisel3] (private[chisel3] underlying: Underlying[A]) extends SealedHierarchy[A] {
underlying match {
case Proto(p: IsClone[_]) => chisel3.internal.throwException("Cannot have a Proto with a clone!")
case other => //Ok
}
/** @return the context of any Data's return from inside the instance */
private[chisel3] def getInnerDataContext: Option[BaseModule] = underlying match {
case Proto(value: BaseModule) => Some(value)
case Proto(value: IsInstantiable) => None
case Clone(i: BaseModule) => Some(i)
case Clone(i: InstantiableClone[_]) => i.getInnerContext
}
/** @return the context this instance. Note that for non-module clones, getInnerDataContext will be the same as getClonedParent */
private[chisel3] def getClonedParent: Option[BaseModule] = underlying match {
case Proto(value: BaseModule) => value._parent
case Clone(i: BaseModule) => i._parent
case Clone(i: InstantiableClone[_]) => i.getInnerContext
}
/** Used by Chisel's internal macros. DO NOT USE in your normal Chisel code!!!
* Instead, mark the field you are accessing with [[@public]]
*
* Given a selector function (that) which selects a member from the original, return the
* corresponding member from the instance.
*
* Our @instantiable and @public macros generate the calls to this apply method
*
* By calling this function, we summon the proper Lookupable typeclass from our implicit scope.
*
* @param that a user-specified lookup function
* @param lookup typeclass which contains the correct lookup function, based on the types of A and B
* @param macroGenerated a value created in the macro, to make it harder for users to use this API
*/
def _lookup[B, C](
that: A => B
)(
implicit lookup: Lookupable[B],
macroGenerated: chisel3.internal.MacroGenerated
): lookup.C = {
lookup.instanceLookup(that, this)
}
/** Returns the definition of this Instance */
override def toDefinition: Definition[A] = new Definition(Proto(proto))
override def toInstance: Instance[A] = this
}
/** Factory methods for constructing [[Instance]]s */
object Instance extends SourceInfoDoc {
implicit class InstanceBaseModuleExtensions[T <: BaseModule](i: Instance[T]) {
/** If this is an instance of a Module, returns the toTarget of this instance
* @return target of this instance
*/
def toTarget: IsModule = i.underlying match {
case Proto(x: BaseModule) => x.getTarget
case Clone(x: IsClone[_] with BaseModule) => x.getTarget
}
/** If this is an instance of a Module, returns the toAbsoluteTarget of this instance
* @return absoluteTarget of this instance
*/
def toAbsoluteTarget: IsModule = i.underlying match {
case Proto(x) => x.toAbsoluteTarget
case Clone(x: IsClone[_] with BaseModule) => x.toAbsoluteTarget
}
}
/** A constructs an [[Instance]] from a [[Definition]]
*
* @param definition the Module being created
* @return an instance of the module definition
*/
def apply[T <: BaseModule with IsInstantiable](definition: Definition[T]): Instance[T] =
macro InstanceTransform.apply[T]
/** A constructs an [[Instance]] from a [[Definition]]
*
* @param definition the Module being created
* @return an instance of the module definition
*/
def do_apply[T <: BaseModule with IsInstantiable](
definition: Definition[T]
)(
implicit sourceInfo: SourceInfo,
compileOptions: CompileOptions
): Instance[T] = {
// Check to see if the module is already defined internally or externally
val existingMod = Builder.components.map {
case c: DefModule if c.id == definition.proto => Some(c)
case c: DefBlackBox if c.name == definition.proto.name => Some(c)
case _ => None
}.flatten
if (existingMod.isEmpty) {
// Add a Definition that will get emitted as an ExtModule so that FIRRTL
// does not complain about a missing element
val extModName = Builder.importDefinitionMap.getOrElse(
definition.proto.name,
throwException(
"Imported Definition information not found - possibly forgot to add ImportDefinition annotation?"
)
)
class EmptyExtModule extends ExtModule {
override def desiredName: String = extModName
override def generateComponent(): Option[Component] = {
require(!_closed, s"Can't generate $desiredName module more than once")
_closed = true
val firrtlPorts = definition.proto.getModulePorts.map { port => Port(port, port.specifiedDirection) }
val component = DefBlackBox(this, definition.proto.name, firrtlPorts, SpecifiedDirection.Unspecified, params)
Some(component)
}
}
Definition(new EmptyExtModule() {})
}
val ports = experimental.CloneModuleAsRecord(definition.proto)
val clone = ports._parent.get.asInstanceOf[ModuleClone[T]]
clone._madeFromDefinition = true
new Instance(Clone(clone))
}
}
|
