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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
// See LICENSE for license details.
package firrtl
package annotations
import net.jcazevedo.moultingyaml._
import firrtl.annotations.AnnotationYamlProtocol._
case class AnnotationException(message: String) extends Exception(message)
/** Base type of auxiliary information */
trait Annotation {
/** Update the target based on how signals are renamed */
def update(renames: RenameMap): Seq[Annotation]
/** Pretty Print
*
* @note In [[logger.LogLevel.Debug]] this is called on every Annotation after every Transform
*/
def serialize: String = this.toString
}
/** If an Annotation does not target any [[Named]] thing in the circuit, then all updates just
* return the Annotation itself
*/
trait NoTargetAnnotation extends Annotation {
def update(renames: RenameMap) = Seq(this)
}
/** An Annotation that targets a single [[Named]] thing */
trait SingleTargetAnnotation[T <: Named] extends Annotation {
val target: T
/** Create another instance of this Annotation */
def duplicate(n: T): Annotation
// This mess of @unchecked and try-catch is working around the fact that T is unknown due to type
// erasure. We cannot that newTarget is of type T, but a CastClassException will be thrown upon
// invoking duplicate if newTarget cannot be cast to T (only possible in the concrete subclass)
def update(renames: RenameMap): Seq[Annotation] =
renames.get(target).map(_.map(newT => (newT: @unchecked) match {
case newTarget: T @unchecked =>
try {
duplicate(newTarget)
} catch {
case _: java.lang.ClassCastException =>
val msg = s"${this.getClass.getName} target ${target.getClass.getName} " +
s"cannot be renamed to ${newTarget.getClass}"
throw AnnotationException(msg)
}
})).getOrElse(List(this))
}
trait SingleStringAnnotation extends NoTargetAnnotation {
def value: String
}
object Annotation {
@deprecated("This returns a LegacyAnnotation, use an explicit Annotation type", "1.1")
def apply(target: Named, transform: Class[_ <: Transform], value: String) =
new LegacyAnnotation(target, transform, value)
@deprecated("This uses LegacyAnnotation, use an explicit Annotation type", "1.1")
def unapply(a: LegacyAnnotation): Option[(Named, Class[_ <: Transform], String)] =
Some((a.target, a.transform, a.value))
}
// Constructor is private so that we can still construct these internally without deprecation
// warnings
final case class LegacyAnnotation private[firrtl] (
target: Named,
transform: Class[_ <: Transform],
value: String) extends SingleTargetAnnotation[Named] {
val targetString: String = target.serialize
val transformClass: String = transform.getName
def targets(named: Named): Boolean = named == target
def targets(transform: Class[_ <: Transform]): Boolean = transform == this.transform
/**
* This serialize is basically a pretty printer, actual serialization is handled by
* AnnotationYamlProtocol
* @return a nicer string than the raw case class default
*/
override def serialize: String = {
s"Annotation(${target.serialize},${transform.getCanonicalName},$value)"
}
def update(tos: Seq[Named]): Seq[Annotation] = {
check(target, tos, this)
propagate(target, tos, duplicate)
}
def propagate(from: Named, tos: Seq[Named], dup: Named=>Annotation): Seq[Annotation] = tos.map(dup(_))
def check(from: Named, tos: Seq[Named], which: Annotation): Unit = {}
def duplicate(n: Named) = new LegacyAnnotation(n, transform, value)
}
// Private so that LegacyAnnotation can only be constructed via deprecated Annotation.apply
private[firrtl] object LegacyAnnotation {
// ***** Everything below here is to help people migrate off of old annotations *****
def errorIllegalAnno(name: String) =
throw new Exception(s"Old-style annotations that look like $name are no longer supported")
private val OldDeletedRegex = """(?s)DELETED by ([^\n]*)\n(.*)""".r
private val PinsRegex = "pins:(.*)".r
private val SourceRegex = "source (.+)".r
private val SinkRegex = "sink (.+)".r
import firrtl.transforms._
import firrtl.passes._
import firrtl.passes.memlib._
import firrtl.passes.wiring._
import firrtl.passes.clocklist._
// Attempt to convert common Annotations and error on the rest of old-style build-in annotations
def convertLegacyAnno(anno: LegacyAnnotation): Annotation = anno match {
// All old-style Emitter annotations are illegal
case LegacyAnnotation(_,_,"emitCircuit") => errorIllegalAnno("EmitCircuitAnnotation")
case LegacyAnnotation(_,_,"emitAllModules") => errorIllegalAnno("EmitAllModulesAnnotation")
case LegacyAnnotation(_,_,value) if value.startsWith("emittedFirrtlCircuit") =>
errorIllegalAnno("EmittedFirrtlCircuitAnnotation")
case LegacyAnnotation(_,_,value) if value.startsWith("emittedFirrtlModule") =>
errorIllegalAnno("EmittedFirrtlModuleAnnotation")
case LegacyAnnotation(_,_,value) if value.startsWith("emittedVerilogCircuit") =>
errorIllegalAnno("EmittedVerilogCircuitAnnotation")
case LegacyAnnotation(_,_,value) if value.startsWith("emittedVerilogModule") =>
errorIllegalAnno("EmittedVerilogModuleAnnotation")
// People shouldn't be trying to pass deleted annotations to Firrtl
case LegacyAnnotation(_,_,OldDeletedRegex(_,_)) => errorIllegalAnno("DeletedAnnotation")
// Some annotations we'll try to support
case LegacyAnnotation(named, t, _) if t == classOf[InlineInstances] => InlineAnnotation(named)
case LegacyAnnotation(n: ModuleName, t, outputConfig) if t == classOf[ClockListTransform] =>
ClockListAnnotation(n, outputConfig)
case LegacyAnnotation(CircuitName(_), transform, "") if transform == classOf[InferReadWrite] =>
InferReadWriteAnnotation
case LegacyAnnotation(_,_,PinsRegex(pins)) => PinAnnotation(pins.split(" "))
case LegacyAnnotation(_, t, value) if t == classOf[ReplSeqMem] =>
val args = value.split(" ")
require(args.size == 2, "Something went wrong, stop using legacy ReplSeqMemAnnotation")
ReplSeqMemAnnotation(args(0), args(1))
case LegacyAnnotation(c: ComponentName, transform, "nodedupmem!")
if transform == classOf[ResolveMemoryReference] => NoDedupMemAnnotation(c)
case LegacyAnnotation(m: ModuleName, transform, "nodedup!")
if transform == classOf[DedupModules] => NoDedupAnnotation(m)
case LegacyAnnotation(c: ComponentName, _, SourceRegex(pin)) => SourceAnnotation(c, pin)
case LegacyAnnotation(n, _, SinkRegex(pin)) => SinkAnnotation(n, pin)
case LegacyAnnotation(m: ModuleName, t, text) if t == classOf[BlackBoxSourceHelper] =>
text.split("\n", 3).toList match {
case "resource" :: id :: _ => BlackBoxResourceAnno(m, id)
case "inline" :: name :: text :: _ => BlackBoxInlineAnno(m, name, text)
case "targetDir" :: targetDir :: _ => BlackBoxTargetDirAnno(targetDir)
case _ => errorIllegalAnno("BlackBoxSourceAnnotation")
}
case LegacyAnnotation(_, transform, "noDCE!") if transform == classOf[DeadCodeElimination] =>
NoDCEAnnotation
case LegacyAnnotation(c: ComponentName, _, "DONTtouch!") => DontTouchAnnotation(c)
case LegacyAnnotation(c: ModuleName, _, "optimizableExtModule!") =>
OptimizableExtModuleAnnotation(c)
case other => other
}
def convertLegacyAnnos(annos: Seq[Annotation]): Seq[Annotation] = {
var warned: Boolean = false
annos.map {
case legacy: LegacyAnnotation =>
val annox = convertLegacyAnno(legacy)
if (!warned && (annox ne legacy)) {
val msg = s"A LegacyAnnotation was automatically converted.\n" + (" "*9) +
"This functionality will soon be removed. Please migrate to new annotations."
Driver.dramaticWarning(msg)
warned = true
}
annox
case other => other
}
}
}
case class DeletedAnnotation(xFormName: String, anno: Annotation) extends NoTargetAnnotation {
override def serialize: String = s"""DELETED by $xFormName\n${anno.serialize}"""
}
|
