Class: Udb::AbstractCondition Abstract

Inherits:
Object
  • Object
show all
Extended by:
T::Helpers, T::Sig
Defined in:
lib/udb/condition.rb,
lib/udb/condition.rb

Overview

This class is abstract.

It cannot be directly instantiated. Subclasses must implement the abstract methods below.

Base class to represent any condition in the UDB data, and to connect/test them

Conditions constructed from UDB data need context to be evaluated; for example, a condition that requires extension A to be implemented implies that Zaamo and Zalrsc must also be implemented.

We add this implied information in a step called expand. Many methods of AbstractCondition take an optional expand: argument that, when true, expands the condition before operating on it.

Instance Method Summary collapse

Instance Method Details

#&(other) ⇒ AbstractCondition

This method is abstract.

logical conjunction

Parameters:

Returns:



361
 
# File 'lib/udb/condition.rb', line 361

def &(other); end

#-@ ⇒ AbstractCondition

This method is abstract.

logical negation

we use - instead of ! for negation to avoid ambiguous situations like:

!condition.satisfiable?
   (is this "negate condition is satisfiable" or "condition is unsatisfiable")

Returns:



374
 
# File 'lib/udb/condition.rb', line 374

def -@; end

#always_implies?(other_condition) ⇒ Boolean

Parameters:

Returns:

  • (Boolean) 


270
271
272
 
# File 'lib/udb/condition.rb', line 270

def always_implies?(other_condition)
  other_condition.covered_by?(self)
end

#compatible?(other) ⇒ Boolean

is it possible for this condition and other to be simultaneously true?

Parameters:

Returns:

  • (Boolean) 


212
213
214
 
# File 'lib/udb/condition.rb', line 212

def compatible?(other)
  (self & other).satisfiable?
end

#could_be_satisfied_by_cfg_arch?(cfg_arch) ⇒ Boolean

for the given config arch, is condition satisfiable?

Parameters:

Returns:

  • (Boolean) 


241
242
243
 
# File 'lib/udb/condition.rb', line 241

def could_be_satisfied_by_cfg_arch?(cfg_arch)
  satisfied_by_cfg_arch?(cfg_arch) != SatisfiedResult::No
end

#covered_by?(other_condition) ⇒ Boolean

Parameters:

Returns:

  • (Boolean) 


255
256
257
258
259
260
261
262
263
264
265
266
267
 
# File 'lib/udb/condition.rb', line 255

def covered_by?(other_condition)
  # cover means other_condition always implies self
  # can test that by seeing if the contradiction is satisfiable, i.e.:
  # if other_condition -> self , contradition would be other_condition & not self
  contradiction = LogicNode.new(
    LogicNodeType::And,
    [
      other_condition.to_logic_tree(expand: true),
      LogicNode.new(LogicNodeType::Not, [to_logic_tree(expand: true)])
    ]
  )
  !contradiction.satisfiable?(@cfg_arch)
end

#empty? ⇒ Boolean

This method is abstract.

returns true if this condition is always true or always false (does not depend on extensions or parameters)

Returns:

  • (Boolean) 


128
 
# File 'lib/udb/condition.rb', line 128

def empty?; end

#equivalent?(other) ⇒ Boolean

is this condition logically equivalent to other? this is true logical equivalence, not just syntatic equivalence, e.g.:

(a || a) is equivalent to (a)

Parameters:

Returns:

  • (Boolean) 


249
250
251
252
 
# File 'lib/udb/condition.rb', line 249

def equivalent?(other)
  contradition = -(self.implies(other) & other.implies(self))
  contradition.unsatisfiable?
end

#ext_req_terms(expand:) ⇒ Array<ExtensionRequirement>

return list of all extension requirements in the condition

if expand is true, expand the condition to include transitive requirements

Parameters:

  • expand (Boolean)

Returns:



186
187
188
189
190
191
192
193
194
 
# File 'lib/udb/condition.rb', line 186

def ext_req_terms(expand:)
  if expand
    @expanded_ext_req_terms ||=
      to_logic_tree(expand:).terms.grep(ExtensionTerm).map { |term| term.to_ext_req(@cfg_arch) }
  else
    @unexpanded_ext_req_terms ||=
      to_logic_tree(expand:).terms.grep(ExtensionTerm).map { |term| term.to_ext_req(@cfg_arch) }
  end
end

#has_extension_requirement? ⇒ Boolean

This method is abstract.

true if the condition references any extension

Returns:

  • (Boolean) 


280
 
# File 'lib/udb/condition.rb', line 280

def has_extension_requirement?; end

#has_param? ⇒ Boolean

This method is abstract.

true if the condition references any parameter

Returns:

  • (Boolean) 


276
 
# File 'lib/udb/condition.rb', line 276

def has_param?; end

#implied_extension_conflicts(expand: true) ⇒ Array<ConditionalExtensionRequirement>

This method is abstract.

inversion of implied_extension_requirements

Parameters:

  • expand (Boolean) (defaults to: true)

Returns:



357
 
# File 'lib/udb/condition.rb', line 357

def implied_extension_conflicts(expand: true); end

#implied_extension_requirements(expand: true) ⇒ Array<ConditionalExtensionRequirement>

This method is abstract.

assuming that the condition represents an extension dependency, return the specified extensions along with the condition under which they apply

specifically, this returns the complete list of positive terms (terms that are not negated in solution) of requirements, along with a conditionthat must hold for condition to be satisfied when the positive term is met

This list is not transitive; if an implication I1 implies another extension I2, only I1 shows up in the list

Examples:

given the equation (representing implications of the "C" extension):
   Zca@1.0.0 AND (!F OR Zcf@1.0.0) AND (!D OR Zcd@1.0.0)

return:
  [
     { ext_req: Zca@1.0.0, cond: True },
     { ext_req: Zcf@1.0.0, cond: !F },
     { ext_req: Zcd@1.0.0, cond: !D }
  ]
given the equation
  Zc AND ((Zc1 AND Zc2) OR (!Zcond))

return
  [
    { ext_ver: Zc,  cond True},
    { ext_ver: Zc1, cond: !Zcond},
    { ext_ver: Zc2, cond: !Zcond}
  ]

Parameters:

  • expand (Boolean) (defaults to: true)

Returns:



353
 
# File 'lib/udb/condition.rb', line 353

def implied_extension_requirements(expand: true); end

#implies(other) ⇒ AbstractCondition

logical implication

a.implies(b) means:

if a; then b

Parameters:

Returns:



382
383
384
 
# File 'lib/udb/condition.rb', line 382

def implies(other)
  -self | other
end

#mentions?(term, expand: true) ⇒ Boolean

is this condition in any way affected by term?

Parameters:

Returns:

  • (Boolean) 


148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/udb/condition.rb', line 148

def mentions?(term, expand: true)
  to_logic_tree(expand:).terms.any? do |t|
    case t
    when ExtensionTerm
      (term.is_a?(Extension) || term.is_a?(ExtensionVersion) || term.is_a?(ExtensionRequirement)) && (term.name == t.name)
    when ParameterTerm
      (term.is_a?(Parameter) || term.is_a?(ParameterWithValue)) && (term.name == t.name)
    else
      false
    end
  end
end

#mentions_xlen?(expand: true) ⇒ Boolean

Parameters:

  • expand (Boolean) (defaults to: true)

Returns:

  • (Boolean) 


162
163
164
165
166
 
# File 'lib/udb/condition.rb', line 162

def mentions_xlen?(expand: true)
  to_logic_tree(expand:).terms.any? do |t|
    t.is_a?(XlenTerm)
  end
end

#minimize(expand: true) ⇒ AbstractCondition

This method is abstract.

minimizes the condition. see LogicNode#minimize when expand is false, minimize the condition without expanding first when expand is true, expand the condition and then minimize

Parameters:

  • expand (Boolean) (defaults to: true)

Returns:



286
 
# File 'lib/udb/condition.rb', line 286

def minimize(expand: true); end

#param_terms(expand:) ⇒ Array<Parameter>

return list of all parameters in the condition

if expand is true, expand the condition to include transitive requirements

Parameters:

  • expand (Boolean)

Returns:



200
201
202
203
204
205
206
207
208
 
# File 'lib/udb/condition.rb', line 200

def param_terms(expand:)
  if expand
    @expanded_param_terms ||=
      to_logic_tree(expand:).terms.grep(ParameterTerm).map { |term| @cfg_arch.param(term.name) }
  else
    @unexpanded_param_terms ||=
      to_logic_tree(expand:).terms.grep(ParameterTerm).map { |term| @cfg_arch.param(term.name) }
  end
end

#partial_eval(ext_reqs: [], expand: true) ⇒ AbstractCondition

This method is abstract.

Parameters:

Returns:



221
 
# File 'lib/udb/condition.rb', line 221

def partial_eval(ext_reqs: [], expand: true); end

#partially_evaluate_for_params(cfg_arch, expand:) ⇒ AbstractCondition

This method is abstract.

partially evaluate by replacing any known parameter terms with true/false, and returning a new condition

Parameters:

Returns:



226
 
# File 'lib/udb/condition.rb', line 226

def partially_evaluate_for_params(cfg_arch, expand:); end

#rv32_only? ⇒ Boolean

is this condition only satisfied when xlen == 32?

Returns:

  • (Boolean) 


170
171
172
173
 
# File 'lib/udb/condition.rb', line 170

def rv32_only?
  (self & Condition.not(Condition::Xlen32, @cfg_arch)).unsatisfiable? & \
  (self & Condition.not(Condition::Xlen64, @cfg_arch)).satisfiable?
end

#rv64_only? ⇒ Boolean

is this condition only satisfied when xlen == 64?

Returns:

  • (Boolean) 


177
178
179
180
 
# File 'lib/udb/condition.rb', line 177

def rv64_only?
  (self & Condition.not(Condition::Xlen64, @cfg_arch)).unsatisfiable? & \
  (self & Condition.not(Condition::Xlen32, @cfg_arch)).satisfiable?
end

#satisfiability_depends_on_ext_req?(_ext_req, include_requirements: false) ⇒ Boolean

This method is abstract.

If ext_req is not satisfied, is condition satisfiable? When include_requirements is true, also assume that the ext_req’s requirements are not met

Parameters:

Returns:

  • (Boolean) 


237
 
# File 'lib/udb/condition.rb', line 237

def satisfiability_depends_on_ext_req?(_ext_req, include_requirements: false); end

#satisfiable? ⇒ Boolean

This method is abstract.

is this condition satisfiable?

Returns:

  • (Boolean) 


140
 
# File 'lib/udb/condition.rb', line 140

def satisfiable?; end

#satisfied_by_cfg_arch?(_cfg_arch) ⇒ SatisfiedResult

This method is abstract.

Returns if the condition is, possibly is, or is definitely not satisfied by cfg_arch.

Parameters:

Returns:

  • (SatisfiedResult) —

    if the condition is, possibly is, or is definitely not satisfied by cfg_arch



218
 
# File 'lib/udb/condition.rb', line 218

def satisfied_by_cfg_arch?(_cfg_arch); end

#satisfied_by_ext_req?(ext_req, include_requirements: false) ⇒ Boolean

This method is abstract.

is condition satisfied if ext_req is the only thing defined?

When include_requirements is true, expand the condition before evaluating

Parameters:

Returns:

  • (Boolean) 


232
 
# File 'lib/udb/condition.rb', line 232

def satisfied_by_ext_req?(ext_req, include_requirements: false); end

#to_asciidoc ⇒ String

This method is abstract.

string representation of condition in Asciidoc

Returns:

  • (String) 


318
 
# File 'lib/udb/condition.rb', line 318

def to_asciidoc; end

#to_h ⇒ Hash{String => T.untyped}, Boolean

This method is abstract.

convert condition into UDB-compatible hash

Returns:

  • (Hash{String => T.untyped}, Boolean) 


290
 
# File 'lib/udb/condition.rb', line 290

def to_h; end

#to_idl(cfg_arch) ⇒ String

This method is abstract.

convert condition into valid IDL

Parameters:

Returns:

  • (String) 


300
 
# File 'lib/udb/condition.rb', line 300

def to_idl(cfg_arch); end

#to_logic_tree(expand:) ⇒ LogicNode

This method is abstract.

convert to the underlying LogicNode-based tree

Parameters:

  • expand (Boolean)

Returns:



132
 
# File 'lib/udb/condition.rb', line 132

def to_logic_tree(expand:); end

#to_logic_tree_internal ⇒ LogicNode

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

This method is abstract.

Returns:



136
 
# File 'lib/udb/condition.rb', line 136

def to_logic_tree_internal; end

#to_s(expand: false) ⇒ String

This method is abstract.

string representation when expand is true, return the full expanded condition

Parameters:

  • expand (Boolean) (defaults to: false)

Returns:

  • (String) 


305
 
# File 'lib/udb/condition.rb', line 305

def to_s(expand: false); end

#to_s_pretty ⇒ String

This method is abstract.

condition in prose

Returns:

  • (String) 


309
 
# File 'lib/udb/condition.rb', line 309

def to_s_pretty; end

#to_s_with_value(cfg_arch, expand:) ⇒ String

This method is abstract.

string representation, annotated with actual values of terms where known useful for debugging

Parameters:

Returns:

  • (String) 


314
 
# File 'lib/udb/condition.rb', line 314

def to_s_with_value(cfg_arch, expand:); end

#to_yaml ⇒ String

convert condition into UDB-compatible YAML string

Returns:

  • (String) 


294
295
296
 
# File 'lib/udb/condition.rb', line 294

def to_yaml
  YAML.dump(to_h)
end

#unsatisfiable? ⇒ Boolean

This method is abstract.

is this condition unsatisfiable?

Returns:

  • (Boolean) 


144
 
# File 'lib/udb/condition.rb', line 144

def unsatisfiable?; end

#|(other) ⇒ AbstractCondition

This method is abstract.

logical disjunction

Parameters:

Returns:



365
 
# File 'lib/udb/condition.rb', line 365

def |(other); end