diff options
Diffstat (limited to 'src/main/scala/firrtl/annotations/Annotation.scala')
| -rw-r--r-- | src/main/scala/firrtl/annotations/Annotation.scala | 125 |
1 files changed, 1 insertions, 124 deletions
diff --git a/src/main/scala/firrtl/annotations/Annotation.scala b/src/main/scala/firrtl/annotations/Annotation.scala index 3e58a0d7..a382f685 100644 --- a/src/main/scala/firrtl/annotations/Annotation.scala +++ b/src/main/scala/firrtl/annotations/Annotation.scala @@ -127,130 +127,7 @@ trait MultiTargetAnnotation extends Annotation { def flat(): AnnotationSeq = crossJoin(targets).map(r => duplicate(r.map(Seq(_)))) } -@deprecated("Just extend NoTargetAnnotation", "1.1") -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): LegacyAnnotation = - 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): LegacyAnnotation = 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): Annotation = - 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] => - val nArgs = 3 - text.split("\n", nArgs).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.toTarget) - case LegacyAnnotation(c: ModuleName, _, "optimizableExtModule!") => - OptimizableExtModuleAnnotation(c) - case other => other - } - def convertLegacyAnnos(annos: AnnotationSeq): AnnotationSeq = { - 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." - StageUtils.dramaticWarning(msg) - warned = true - } - annox - case other => other - } - } -} +object Annotation case class DeletedAnnotation(xFormName: String, anno: Annotation) extends NoTargetAnnotation { override def serialize: String = s"""DELETED by $xFormName\n${anno.serialize}""" |