SYMBOL INDEX (2352 symbols across 274 files) FILE: bench/codon/binary_trees.cpp type Node (line 8) | struct Node { function make_tree (line 13) | inline std::unique_ptr make_tree(int d) { function check_tree (line 21) | inline int check_tree(const std::unique_ptr &node) { function make_check (line 28) | inline int make_check(const std::pair &itde) { type ArgChunks (line 34) | struct ArgChunks { method ArgChunks (line 38) | ArgChunks(int i, int d, int chunksize = 5000) method next (line 43) | bool next() { function main (line 54) | int main(int argc, char *argv[]) { FILE: bench/codon/binary_trees.py class Node (line 12) | class Node: method __init__ (line 13) | def __init__(self, left = None, right = None): function make_tree (line 17) | def make_tree(d): function check_tree (line 20) | def check_tree(node): function make_check (line 27) | def make_check(itde, make=make_tree, check=check_tree): function get_argchunks (line 31) | def get_argchunks(i, d, chunksize=5000): function main (line 42) | def main(n, min_depth=4): FILE: bench/codon/chaos.py class GVector (line 19) | class GVector(object): method __init__ (line 21) | def __init__(self, x=0, y=0, z=0): method Mag (line 26) | def Mag(self): method dist (line 29) | def dist(self, other): method __add__ (line 34) | def __add__(self, other): method __sub__ (line 40) | def __sub__(self, other): method __mul__ (line 43) | def __mul__(self, other): method linear_combination (line 48) | def linear_combination(self, other, l1, l2=None): method __str__ (line 56) | def __str__(self): method __repr__ (line 59) | def __repr__(self): class Spline (line 63) | class Spline(object): method __init__ (line 66) | def __init__(self, points, degree, knots): method GetDomain (line 83) | def GetDomain(self): method __call__ (line 88) | def __call__(self, u): method GetIndex (line 111) | def GetIndex(self, u): method __len__ (line 121) | def __len__(self): method __repr__ (line 124) | def __repr__(self): function write_ppm (line 128) | def write_ppm(im, filename): class Chaosgame (line 144) | class Chaosgame(object): method __init__ (line 146) | def __init__(self, splines, thickness=0.1): method get_random_trafo (line 168) | def get_random_trafo(self): method transform_point (line 177) | def transform_point(self, point, trafo=None): method truncate (line 203) | def truncate(self, point): method create_image_chaos (line 213) | def create_image_chaos(self, w, h, iterations, filename, rng_seed): function main (line 237) | def main(): FILE: bench/codon/fannkuch.py function perm (line 6) | def perm(n, i): FILE: bench/codon/float.py class Point (line 7) | class Point: method __init__ (line 12) | def __init__(self, i): method __repr__ (line 17) | def __repr__(self): method normalize (line 20) | def normalize(self): method maximize (line 29) | def maximize(self, other): function maximize (line 36) | def maximize(points): function benchmark (line 43) | def benchmark(n): FILE: bench/codon/go.py function to_pos (line 19) | def to_pos(x, y): function to_xy (line 23) | def to_xy(pos): class Square (line 28) | class Square: method __init__ (line 30) | def __init__(self, board, pos): method set_neighbours (line 38) | def set_neighbours(self): method move (line 46) | def move(self, color): method remove (line 72) | def remove(self, reference, update=True): method find (line 91) | def find(self, update=False): method __repr__ (line 99) | def __repr__(self): class EmptySet (line 103) | class EmptySet: method __init__ (line 105) | def __init__(self, board): method random_choice (line 110) | def random_choice(self): method add (line 122) | def add(self, pos): method remove (line 126) | def remove(self, pos): method set (line 130) | def set(self, i, pos): class ZobristHash (line 135) | class ZobristHash: method __init__ (line 137) | def __init__(self, board): method update (line 146) | def update(self, square, color): method add (line 150) | def add(self): method dupe (line 153) | def dupe(self): class Board (line 157) | class Board: method __init__ (line 159) | def __init__(self): method reset (line 165) | def reset(self): method move (line 178) | def move(self, pos): method random_move (line 192) | def random_move(self): method useful_fast (line 195) | def useful_fast(self, square): method useful (line 202) | def useful(self, pos): method useful_moves (line 238) | def useful_moves(self): method replay (line 241) | def replay(self, history): method score (line 245) | def score(self, color): method check (line 263) | def check(self): method __repr__ (line 308) | def __repr__(self): class UCTNode (line 317) | class UCTNode: method __init__ (line 319) | def __init__(self): method play (line 327) | def play(self, board): method select (line 350) | def select(self, board): method random_playout (line 363) | def random_playout(self, board): method update_path (line 370) | def update_path(self, board, color, path): method score (line 385) | def score(self): method best_child (line 393) | def best_child(self): method best_visited (line 402) | def best_visited(self): function computer_move (line 431) | def computer_move(board): function versus_cpu (line 446) | def versus_cpu(): FILE: bench/codon/mandelbrot.py function scale (line 6) | def scale(x, a, b): FILE: bench/codon/nbody.cpp type Body (line 15) | struct Body { function values (line 45) | auto values(std::unordered_map &m) { function combinations (line 53) | auto combinations(const std::vector &v) { function advance (line 66) | void advance(double dt, int n, std::vector &bodies = SYSTEM, function report_energy (line 98) | void report_energy(std::vector &bodies = SYSTEM, function offset_momentum (line 121) | void offset_momentum(Body &ref, std::vector &bodies = SYSTEM, do... function main (line 140) | int main(int argc, char *argv[]) { FILE: bench/codon/nbody.py function combinations (line 13) | def combinations(l): function advance (line 65) | def advance(dt, n, bodies=SYSTEM, pairs=PAIRS): function report_energy (line 88) | def report_energy(bodies=SYSTEM, pairs=PAIRS, e=0.0): function offset_momentum (line 100) | def offset_momentum(ref, bodies=SYSTEM, px=0.0, py=0.0, pz=0.0): function main (line 111) | def main(n, ref='sun'): FILE: bench/codon/primes.py function is_prime (line 4) | def is_prime(n): FILE: bench/codon/set_partition.cpp function range (line 9) | inline vec range(int start, int stop) { function conforms (line 17) | inline bool conforms(const vec> &candidate, int minsize, int fo... function partition_filtered (line 27) | inline void partition_filtered(const vec &collection, function main (line 74) | int main(int argc, char *argv[]) { FILE: bench/codon/set_partition.py function conforms (line 5) | def conforms(candidate, minsize, forgive): function partition_filtered (line 19) | def partition_filtered(collection, minsize=1, forgive=0): FILE: bench/codon/spectral_norm.py function eval_A (line 20) | def eval_A(i, j): function eval_times_u (line 23) | def eval_times_u(func, u): function part_At_times_u (line 26) | def part_At_times_u(i_u): function part_A_times_u (line 33) | def part_A_times_u(i_u): function eval_AtA_times_u (line 40) | def eval_AtA_times_u(u): function bench_spectral_norm (line 43) | def bench_spectral_norm(loops): FILE: bench/codon/taq.cpp function mean (line 13) | double mean(It begin, It end) { function stdev (line 19) | double stdev(It begin, It end) { function find_peaks (line 28) | std::vector find_peaks(const std::vector &y) { function process_data (line 64) | std::pair, std::vector> function main (line 90) | int main(int argc, char *argv[]) { FILE: bench/codon/taq.py function find_peaks (line 7) | def find_peaks(y): function process_data (line 37) | def process_data(series): FILE: bench/codon/word_count.cpp function main (line 10) | int main(int argc, char *argv[]) { FILE: codon/app/main.cpp function versMsg (line 25) | void versMsg(llvm::raw_ostream &out) { function isMacOS (line 30) | bool isMacOS() { function hasExtension (line 43) | bool hasExtension(const std::string &filename, const std::string &extens... function trimExtension (line 49) | std::string trimExtension(const std::string &filename, const std::string... function makeOutputFilename (line 57) | std::string makeOutputFilename(const std::string &filename, function display (line 66) | void display(const codon::error::ParserErrorInfo &e) { function initLogFlags (line 93) | void initLogFlags(const llvm::cl::opt &log) { type BuildKind (line 99) | enum BuildKind { type OptMode (line 110) | enum OptMode { Debug, Release } type Numerics (line 111) | enum Numerics { C, Python } function docMode (line 114) | int docMode(const std::vector &args, const std::string &ar... function processSource (line 161) | std::unique_ptr processSource( function runMode (line 254) | int runMode(const std::vector &args) { function jitExec (line 270) | std::string jitExec(codon::jit::JIT *jit, const std::string &code) { function jitLoop (line 290) | void jitLoop(codon::jit::JIT *jit, std::istream &fp) { function jitMode (line 306) | int jitMode(const std::vector &args) { function buildMode (line 342) | int buildMode(const std::vector &args, const std::string &... function jupyterMode (line 451) | int jupyterMode(const std::vector &args) { function showCommandsAndExit (line 462) | void showCommandsAndExit() { function otherMode (line 466) | int otherMode(const std::vector &args) { function main (line 479) | int main(int argc, const char **argv) { FILE: codon/cir/analyze/analysis.cpp type codon (line 7) | namespace codon { type ir (line 8) | namespace ir { type analyze (line 9) | namespace analyze { function Result (line 11) | Result *Analysis::doGetAnalysis(const std::string &key) { FILE: codon/cir/analyze/analysis.h function namespace (line 10) | namespace codon { FILE: codon/cir/analyze/dataflow/capture.cpp type codon (line 13) | namespace codon { type ir (line 14) | namespace ir { type analyze (line 15) | namespace analyze { type dataflow (line 16) | namespace dataflow { function contains (line 19) | bool contains(const S &x, T i) { function containsId (line 27) | bool containsId(const S &x, T i) { function shouldTrack (line 35) | bool shouldTrack(const T *x) { function shouldTrack (line 42) | bool shouldTrack(const types::Type *x) { return x && !x->isAtomi... type CaptureContext (line 44) | struct CaptureContext method CaptureContext (line 276) | CaptureContext(RDResult *reaching, DominatorResult *dominating) method CFGraph (line 282) | CFGraph *getCFGraph(const Func *func) { method RDInspector (line 289) | RDInspector *getRDInspector(const Func *func) { method DominatorInspector (line 296) | DominatorInspector *getDomInspector(const Func *func) { function reachable (line 48) | bool reachable(CFBlock *start, CFBlock *end, std::unordered_set<... function happensBefore (line 68) | bool happensBefore(const Value *before, const Value *after, CFGr... type RDManager (line 96) | struct RDManager { type IDPairHash (line 97) | struct IDPairHash { method RDManager (line 107) | explicit RDManager(RDInspector *rd) : rd(rd), cache() {} method getReachingDefinitions (line 109) | std::unordered_set getReachingDefinitions(const Var *var... method isInvalid (line 125) | bool isInvalid(const Var *v) { return rd->isInvalid(v); } type DerivedSet (line 128) | struct DerivedSet { method setReturnCaptured (line 136) | void setReturnCaptured() { method setExternCaptured (line 141) | void setExternCaptured() { method isDerived (line 146) | bool isDerived(const Var *v, const Value *loc, RDManager &rd) ... method isDerived (line 173) | bool isDerived(const Value *v) const { method setDerived (line 177) | void setDerived(const Var *v, const Value *cause, bool shouldA... method setDerived (line 202) | void setDerived(const Value *v) { method size (line 209) | unsigned size() const { method DerivedSet (line 217) | explicit DerivedSet(const Func *func, const Var *root = nullptr) method DerivedSet (line 221) | DerivedSet(const Func *func, const Var *root, const Value *cause) method DerivedSet (line 232) | DerivedSet(const Func *func, const Value *value, CaptureContex... function noCaptureByAnnotation (line 246) | bool noCaptureByAnnotation(const Func *func) { function makeAllCaptureInfo (line 252) | std::vector makeAllCaptureInfo(const Func *func) { function makeNoCaptureInfo (line 260) | std::vector makeNoCaptureInfo(const Func *func, boo... type CaptureContext (line 271) | struct CaptureContext { method CaptureContext (line 276) | CaptureContext(RDResult *reaching, DominatorResult *dominating) method CFGraph (line 282) | CFGraph *getCFGraph(const Func *func) { method RDInspector (line 289) | RDInspector *getRDInspector(const Func *func) { method DominatorInspector (line 296) | DominatorInspector *getDomInspector(const Func *func) { type ExtractVars (line 309) | struct ExtractVars : public util::ConstVisitor { method ExtractVars (line 314) | explicit ExtractVars(CaptureContext &cc) method process (line 317) | void process(const Node *v) { v->accept(*this); } method add (line 319) | void add(const Var *v) { method defaultVisit (line 324) | void defaultVisit(const Node *) override {} method visit (line 326) | void visit(const VarValue *v) override { add(v->getVar()); } method visit (line 328) | void visit(const PointerValue *v) override { add(v->getVar()); } method visit (line 330) | void visit(const CallInstr *v) override { method visit (line 350) | void visit(const YieldInInstr *v) override { method visit (line 357) | void visit(const TernaryInstr *v) override { method visit (line 362) | void visit(const ExtractInstr *v) override { process(v->getVal... method visit (line 364) | void visit(const FlowInstr *v) override { process(v->getValue(... method visit (line 366) | void visit(const dsl::CustomInstr *v) override { function extractVars (line 371) | bool extractVars(CaptureContext &cc, const Value *v, std::vector... type CaptureTracker (line 381) | struct CaptureTracker : public util::Operator { method CaptureTracker (line 388) | CaptureTracker(CaptureContext &cc, const Func *func, bool isArg) method CaptureTracker (line 392) | CaptureTracker(CaptureContext &cc, const BodiedFunc *func) method CaptureTracker (line 423) | CaptureTracker(CaptureContext &cc, const BodiedFunc *func, con... method size (line 428) | unsigned size() const { method forEachDSetOf (line 436) | void forEachDSetOf(Value *v, std::function... method forEachDSetOf (line 446) | void forEachDSetOf(Var *v, Value *loc, std::functiongetRhs(), v->ge... method handle (line 540) | void handle(ExtractInstr *v) override { method handle (line 547) | void handle(InsertInstr *v) override { method handle (line 552) | void handle(CallInstr *v) override { method handle (line 607) | void handle(ForFlow *v) override { method handle (line 627) | void handle(TernaryInstr *v) override { method handle (line 632) | void handle(FlowInstr *v) override { method handle (line 636) | void handle(dsl::CustomInstr *v) override { method handle (line 642) | void handle(ReturnInstr *v) override { method handle (line 647) | void handle(YieldInstr *v) override { method handle (line 652) | void handle(AwaitInstr *v) override { method handle (line 657) | void handle(ThrowInstr *v) override { method runToCompletion (line 663) | void runToCompletion(const Func *func) { function CaptureInfo (line 742) | CaptureInfo CaptureInfo::unknown(const Func *func, types::Type *... function CaptureInfo (line 784) | CaptureInfo escapes(const BodiedFunc *func, const Value *value, ... FILE: codon/cir/analyze/dataflow/capture.h function namespace (line 14) | namespace codon { FILE: codon/cir/analyze/dataflow/cfg.cpp type codon (line 10) | namespace codon { type ir (line 11) | namespace ir { type analyze (line 12) | namespace analyze { type dataflow (line 13) | namespace dataflow { function Value (line 16) | Value *callStage(analyze::dataflow::CFGraph *cfg, PipelineFlow::... function Value (line 25) | Value *convertPipelineToForLoopsHelper(analyze::dataflow::CFGrap... function Value (line 50) | const Value *convertPipelineToForLoops(analyze::dataflow::CFGrap... function buildCFGraph (line 128) | std::unique_ptr buildCFGraph(const BodiedFunc *f) { FILE: codon/cir/analyze/dataflow/cfg.h function namespace (line 18) | namespace codon { function class (line 312) | class CFGraph { function Result (line 452) | struct CFResult : public Result { function class (line 458) | class CFAnalysis : public Analysis { function class (line 466) | class CFVisitor : public util::ConstVisitor { function ostream_formatter (line 550) | struct fmt::formatter : fmt::ostr... FILE: codon/cir/analyze/dataflow/dominator.cpp type codon (line 7) | namespace codon { type ir (line 8) | namespace ir { type analyze (line 9) | namespace analyze { type dataflow (line 10) | namespace dataflow { FILE: codon/cir/analyze/dataflow/dominator.h function namespace (line 12) | namespace codon { FILE: codon/cir/analyze/dataflow/reaching.cpp type codon (line 8) | namespace codon { type ir (line 9) | namespace ir { type analyze (line 10) | namespace analyze { type dataflow (line 11) | namespace dataflow { function id_t (line 14) | id_t getKilled(const Value *val) { function getGenerated (line 23) | std::pair getGenerated(const Value *val) { type WorkList (line 37) | struct WorkList { method push (line 41) | void push(T *a) { method T (line 49) | T *pop() { method WorkList (line 58) | WorkList(S *x) : have(), queue() { type BitSet (line 65) | struct BitSet { method allocSize (line 67) | static unsigned allocSize(unsigned size) { return (size + B - ... method BitSet (line 71) | explicit BitSet(unsigned size) : words(allocSize(size), 0) {} method BitSet (line 73) | BitSet copy(unsigned size) const { method set (line 79) | void set(unsigned bit) { words.data()[bit / B] |= (1UL << (bit... method get (line 81) | bool get(unsigned bit) const { method equals (line 85) | bool equals(const BitSet &other, unsigned size) { method clear (line 90) | void clear(unsigned size) { std::memset(words.data(), 0, alloc... method setAll (line 92) | void setAll(unsigned size) { method overwrite (line 96) | void overwrite(const BitSet &other, unsigned size) { method update (line 100) | void update(const BitSet &other, unsigned size) { method subtract (line 109) | void subtract(const BitSet &other, unsigned size) { type BlockBitSets (line 119) | struct BlockBitSets { method BlockBitSets (line 126) | BlockBitSets(T *blk, BitSet gen, BitSet kill, BitSet in, BitSe... FILE: codon/cir/analyze/dataflow/reaching.h function namespace (line 10) | namespace codon { function namespace (line 47) | namespace std { function namespace (line 56) | namespace codon { FILE: codon/cir/analyze/module/global_vars.cpp type codon (line 7) | namespace codon { type ir (line 8) | namespace ir { type analyze (line 9) | namespace analyze { type module (line 10) | namespace module { type GlobalVarAnalyzer (line 12) | struct GlobalVarAnalyzer : public util::Operator { method handle (line 15) | void handle(PointerValue *v) override { method handle (line 20) | void handle(AssignInstr *v) override { FILE: codon/cir/analyze/module/global_vars.h function namespace (line 9) | namespace codon { FILE: codon/cir/analyze/module/side_effect.cpp type codon (line 12) | namespace codon { type ir (line 13) | namespace ir { type analyze (line 14) | namespace analyze { type module (line 15) | namespace module { function T (line 17) | T max(T &&t) { return std::forward(t); } function max (line 20) | typename std::common_type::type max(T0 &&val1, T1... type VarUseAnalyzer (line 25) | struct VarUseAnalyzer : public util::Operator { method preHook (line 29) | void preHook(Node *v) override { method handle (line 35) | void handle(AssignInstr *v) override { ++varAssignCounts[v->ge... type SideEfectAnalyzer (line 38) | struct SideEfectAnalyzer : public util::ConstVisitor { method Status (line 41) | static Status getFunctionStatusFromAttributes(const Func *v, b... method SideEfectAnalyzer (line 85) | SideEfectAnalyzer(VarUseAnalyzer &vua, dataflow::CaptureResult... method has (line 91) | bool has(const T *v) { method set (line 95) | void set(const T *v, Status expr, Status func = Status::PURE) { method Status (line 100) | Status process(const T *v) { method getVarAssignStatus (line 110) | std::pair getVarAssignStatus(const Var *var) { method handleVarAssign (line 132) | void handleVarAssign(const Value *v, const Var *var, Status ba... method visit (line 137) | void visit(const Module *v) override { method visit (line 144) | void visit(const Var *v) override { set(v, Status::PURE); } method visit (line 146) | void visit(const BodiedFunc *v) override { method visit (line 161) | void visit(const ExternalFunc *v) override { method visit (line 165) | void visit(const InternalFunc *v) override { set(v, Status::PU... method visit (line 167) | void visit(const LLVMFunc *v) override { set(v, getFunctionSta... method visit (line 169) | void visit(const VarValue *v) override { set(v, Status::PURE); } method visit (line 171) | void visit(const PointerValue *v) override { set(v, Status::PU... method visit (line 173) | void visit(const SeriesFlow *v) override { method visit (line 181) | void visit(const IfFlow *v) override { method visit (line 186) | void visit(const WhileFlow *v) override { method visit (line 190) | void visit(const ForFlow *v) override { method visit (line 200) | void visit(const ImperativeForFlow *v) override { method visit (line 210) | void visit(const TryCatchFlow *v) override { method visit (line 224) | void visit(const PipelineFlow *v) override { method visit (line 247) | void visit(const dsl::CustomFlow *v) override { method visit (line 252) | void visit(const IntConst *v) override { set(v, Status::PURE); } method visit (line 254) | void visit(const FloatConst *v) override { set(v, Status::PURE... method visit (line 256) | void visit(const BoolConst *v) override { set(v, Status::PURE); } method visit (line 258) | void visit(const StringConst *v) override { set(v, Status::PUR... method visit (line 260) | void visit(const dsl::CustomConst *v) override { set(v, Status... method visit (line 262) | void visit(const AssignInstr *v) override { method visit (line 266) | void visit(const ExtractInstr *v) override { set(v, process(v-... method visit (line 268) | void visit(const InsertInstr *v) override { method visit (line 296) | void visit(const CallInstr *v) override { method visit (line 312) | void visit(const StackAllocInstr *v) override { set(v, Status:... method visit (line 314) | void visit(const TypePropertyInstr *v) override { set(v, Statu... method visit (line 316) | void visit(const YieldInInstr *v) override { set(v, Status::NO... method visit (line 318) | void visit(const TernaryInstr *v) override { method visit (line 323) | void visit(const BreakInstr *v) override { set(v, Status::NO_C... method visit (line 325) | void visit(const ContinueInstr *v) override { set(v, Status::N... method visit (line 327) | void visit(const ReturnInstr *v) override { method visit (line 331) | void visit(const YieldInstr *v) override { method visit (line 335) | void visit(const AwaitInstr *v) override { method visit (line 339) | void visit(const ThrowInstr *v) override { method visit (line 344) | void visit(const FlowInstr *v) override { method visit (line 348) | void visit(const dsl::CustomInstr *v) override { FILE: codon/cir/analyze/module/side_effect.h function namespace (line 10) | namespace codon { FILE: codon/cir/attribute.cpp type codon (line 10) | namespace codon { type ir (line 11) | namespace ir { function clone (line 199) | std::unordered_map> FILE: codon/cir/attribute.h function namespace (line 14) | namespace codon { function ostream_formatter (line 356) | struct fmt::formatter : fmt::ostream_formatter {} FILE: codon/cir/base.cpp type codon (line 10) | namespace codon { type ir (line 11) | namespace ir { FILE: codon/cir/base.h function namespace (line 18) | namespace codon { function virtual (line 228) | virtual int replaceUsedType(const std::string &name, types::Type *newTyp... function virtual (line 238) | virtual std::vector getUsedVariables() { return {}; } function virtual (line 240) | virtual std::vector getUsedVariables() const { return {}; } function Node (line 257) | const Node *getActual() const { function virtual (line 271) | virtual bool isConvertible(const void *other) const override { function accept (line 278) | void accept(util::Visitor &v) override { function accept (line 285) | void accept(util::ConstVisitor &v) const override { function Derived (line 305) | Derived *getActual() { function Derived (line 311) | const Derived *getActual() const { function replaceAll (line 319) | void replaceAll(Derived *v) { function ostream_formatter (line 352) | struct fmt::formatter : fmt::ostream_formatter {} FILE: codon/cir/const.cpp type codon (line 5) | namespace codon { type ir (line 6) | namespace ir { FILE: codon/cir/const.h function namespace (line 8) | namespace codon { FILE: codon/cir/dsl/codegen.h function namespace (line 10) | namespace codon { FILE: codon/cir/dsl/nodes.cpp type codon (line 5) | namespace codon { type ir (line 6) | namespace ir { type dsl (line 7) | namespace dsl { type types (line 9) | namespace types { FILE: codon/cir/dsl/nodes.h function namespace (line 15) | namespace util { function namespace (line 21) | namespace codegen { function namespace (line 27) | namespace types { FILE: codon/cir/flow.cpp type codon (line 9) | namespace codon { type ir (line 10) | namespace ir { function findAndReplace (line 12) | int findAndReplace(id_t id, codon::ir::Value *newVal, FILE: codon/cir/flow.h function namespace (line 13) | namespace codon { function Value (line 238) | Value *getStart() const { return start; } function setStart (line 241) | void setStart(Value *val) { start = val; } function setStep (line 247) | void setStep(int64_t val) { step = val; } function Value (line 250) | Value *getEnd() const { return end; } function setEnd (line 253) | void setEnd(Value *val) { end = val; } function Flow (line 256) | Flow *getBody() { return cast(body); } function Flow (line 258) | const Flow *getBody() const { return cast(body); } function setBody (line 261) | void setBody(Flow *f) { body = f; } function Var (line 264) | Var *getVar() { return var; } function Var (line 266) | const Var *getVar() const { return var; } function setVar (line 269) | void setVar(Var *c) { var = c; } function transform (line 285) | const transform::parallel::OMPSched *getSchedule() const { return schedu... function setSchedule (line 288) | void setSchedule(std::unique_ptr s) { function override (line 296) | const override { return {var}; } function Flow (line 324) | Flow *getTrueBranch() { return cast(trueBranch); } function Flow (line 326) | const Flow *getTrueBranch() const { return cast(trueBranch); } function setTrueBranch (line 329) | void setTrueBranch(Flow *f) { trueBranch = f; } function Flow (line 332) | Flow *getFalseBranch() { return cast(falseBranch); } function Flow (line 334) | const Flow *getFalseBranch() const { return cast(falseBranch); } function setFalseBranch (line 337) | void setFalseBranch(Flow *f) { falseBranch = f; } function Value (line 340) | Value *getCond() { return cond; } function Value (line 342) | const Value *getCond() const { return cond; } function setCond (line 345) | void setCond(Value *c) { cond = c; } function Flow (line 372) | const Flow *getHandler() const { return cast(handler); } function setHandler (line 375) | void setHandler(Flow *h) { handler = h; } function setType (line 381) | void setType(types::Type *t) { type = t; } function Var (line 384) | Var *getVar() { return catchVar; } function Var (line 386) | const Var *getVar() const { return catchVar; } function setVar (line 389) | void setVar(Var *v) { catchVar = v; } function Flow (line 417) | const Flow *getBody() const { return cast(body); } function setBody (line 420) | void setBody(Flow *f) { body = f; } function Flow (line 423) | Flow *getElse() { return cast(else_); } function Flow (line 425) | const Flow *getElse() const { return cast(else_); } function setElse (line 428) | void setElse(Flow *f) { else_ = f; } function Flow (line 431) | Flow *getFinally() { return cast(finally); } function Flow (line 433) | const Flow *getFinally() const { return cast(finally); } function setFinally (line 436) | void setFinally(Flow *f) { finally = f; } function push_back (line 464) | void push_back(Catch v) { catches.push_back(v); } function Value (line 529) | Value *front() { return args.front(); } function Value (line 531) | Value *back() { return args.back(); } function Value (line 533) | const Value *front() const { return args.front(); } function Value (line 535) | const Value *back() const { return args.back(); } function push_back (line 544) | void push_back(Value *v) { args.push_back(v); } function setCallee (line 553) | void setCallee(Value *c) { callee = c; } function Value (line 555) | Value *getCallee() { return callee; } function Value (line 557) | const Value *getCallee() const { return callee; } function push_back (line 615) | void push_back(Stage v) { stages.push_back(std::move(v)); } FILE: codon/cir/func.cpp type codon (line 14) | namespace codon { type ir (line 15) | namespace ir { function findAndReplace (line 17) | int findAndReplace(id_t id, codon::ir::Var *newVal, function Var (line 46) | Var *Func::getArgVar(const std::string &n) { FILE: codon/cir/func.h function namespace (line 9) | namespace codon { function Var (line 119) | Var *front() { return symbols.front(); } function Var (line 121) | Var *back() { return symbols.back(); } function Var (line 123) | const Var *front() const { return symbols.front(); } function Var (line 125) | const Var *back() const { return symbols.back(); } function push_back (line 134) | void push_back(Var *v) { symbols.push_back(v); } function Flow (line 142) | Flow *getBody() { return cast(body); } function Flow (line 144) | const Flow *getBody() const { return cast(body); } function setBody (line 147) | void setBody(Flow *b) { body = b; } function override (line 156) | const override { function setLLVMLiterals (line 200) | void setLLVMLiterals(std::vector v) { llvmLiterals = std... function setLLVMDeclarations (line 224) | void setLLVMDeclarations(std::string v) { llvmDeclares = std::move(v); } function setLLVMBody (line 229) | void setLLVMBody(std::string v) { llvmBody = std::move(v); } function ostream_formatter (line 233) | int doReplaceUsedType(const std::string &name, types::Type *newType) ove... FILE: codon/cir/instr.cpp type codon (line 8) | namespace codon { type ir (line 9) | namespace ir { function findAndReplace (line 11) | int findAndReplace(id_t id, codon::ir::Value *newVal, FILE: codon/cir/instr.h function namespace (line 14) | namespace codon { function Value (line 184) | Value *getCallee() { return callee; } function Value (line 186) | const Value *getCallee() const { return callee; } function setCallee (line 189) | void setCallee(Value *c) { callee = c; } function Value (line 201) | Value *front() { return args.front(); } function Value (line 203) | Value *back() { return args.back(); } function Value (line 205) | const Value *front() const { return args.front(); } function Value (line 207) | const Value *back() const { return args.back(); } function push_back (line 216) | void push_back(Value *v) { args.push_back(v); } function setArgs (line 220) | void setArgs(std::vector v) { args = std::move(v); } function setCount (line 253) | void setCount(int64_t c) { count = c; } function setArrayType (line 261) | void setArrayType(types::Type *t) { arrayType = t; } function override (line 265) | const override { return {arrayType}; } type Property (line 272) | enum Property { IS_ATOMIC, IS_CONTENT_ATOMIC, SIZEOF } function setInspectType (line 296) | void setInspectType(types::Type *t) { inspectType = t; } function setProperty (line 302) | void setProperty(Property p) { property = p; } function setType (line 336) | void setType(types::Type *t) { type = t; } function Value (line 367) | Value *getCond() { return cond; } function Value (line 369) | const Value *getCond() const { return cond; } function setCond (line 372) | void setCond(Value *v) { cond = v; } function Value (line 375) | Value *getTrueValue() { return trueValue; } function Value (line 377) | const Value *getTrueValue() const { return trueValue; } function setTrueValue (line 380) | void setTrueValue(Value *v) { trueValue = v; } function Value (line 383) | Value *getFalseValue() { return falseValue; } function Value (line 385) | const Value *getFalseValue() const { return falseValue; } function setFalseValue (line 388) | void setFalseValue(Value *v) { falseValue = v; } function override (line 392) | const override { function setLoop (line 424) | void setLoop(Value *v) { loop = v; } function setLoop (line 449) | void setLoop(Value *v) { loop = v; } function Value (line 470) | const Value *getValue() const { return value; } function setValue (line 473) | void setValue(Value *v) { value = v; } function Value (line 497) | const Value *getValue() const { return value; } function setValue (line 500) | void setValue(Value *v) { value = v; } function Value (line 534) | const Value *getValue() const { return value; } function setValue (line 537) | void setValue(Value *v) { value = v; } function setType (line 541) | void setType(types::Type *t) { type = t; } function override (line 551) | const override { return {value}; } function Value (line 571) | const Value *getValue() const { return value; } function setValue (line 574) | void setValue(Value *v) { value = v; } function Flow (line 602) | const Flow *getFlow() const { return cast(flow); } function setFlow (line 605) | void setFlow(Flow *f) { flow = f; } function Value (line 608) | Value *getValue() { return val; } function Value (line 610) | const Value *getValue() const { return val; } function setValue (line 613) | void setValue(Value *v) { val = v; } function override (line 617) | const override { return {flow, val}; } FILE: codon/cir/llvm/gpu.cpp type codon (line 12) | namespace codon { type ir (line 13) | namespace ir { class GVExtractor (line 36) | class GVExtractor : public llvm::PassInfoMixin { method GVExtractor (line 45) | explicit GVExtractor(std::vector &GVs, bool d... method makeVisible (line 54) | static void makeVisible(llvm::GlobalValue &GV, bool del) { method run (line 81) | llvm::PreservedAnalyses run(llvm::Module &M, llvm::ModuleAnalysisM... function cleanUpName (line 156) | std::string cleanUpName(llvm::StringRef name) { function linkLibdevice (line 176) | void linkLibdevice(llvm::Module *M, const std::string &path) { function codegenVectorizedUnaryLoop (line 222) | void codegenVectorizedUnaryLoop(llvm::IRBuilder<> &B, function codegenVectorizedBinaryLoop (line 283) | void codegenVectorizedBinaryLoop(llvm::IRBuilder<> &B, function remapFunctions (line 386) | void remapFunctions(llvm::Module *M) { function exploreGV (line 677) | void exploreGV(llvm::GlobalValue *G, llvm::SmallPtrSetImpl function moduleToPTX (line 701) | std::string moduleToPTX(llvm::Module *M, std::vector &args) { function typeIdxLookup (line 1389) | int typeIdxLookup(types::Type *type) { function internalFuncMatchesIgnoreArgs (line 1728) | bool internalFuncMatchesIgnoreArgs(const std::string &name, const In... function internalFuncMatches (line 1733) | bool internalFuncMatches(const std::string &name, const InternalFunc... function internalFuncMatches (line 1747) | bool internalFuncMatches(const std::string &name, const InternalFunc... function anyMatch (line 2705) | bool anyMatch(types::Type *type, std::vector types) { FILE: codon/cir/llvm/llvisitor.h function namespace (line 16) | namespace codon { function insertVar (line 226) | void insertVar(const Var *var, llvm::Value *x) { vars.emplace(var->getId... function insertFunc (line 228) | void insertFunc(const Func *func, llvm::Function *x) { function std (line 240) | static std::string getDebugNameForVariable(const Var *x) { function SrcInfo (line 250) | static const SrcInfo *getDefaultSrcInfo() { function SrcInfo (line 255) | static const SrcInfo *getSrcInfo(const Node *x) { function setFlags (line 294) | void setFlags(const std::string &f) { db.flags = f; } function setFunc (line 309) | void setFunc(llvm::Function *f) { func = f; } function setBlock (line 310) | void setBlock(llvm::BasicBlock *b) { block = b; } function setValue (line 311) | void setValue(llvm::Value *v) { value = v; } function setPluginManager (line 412) | void setPluginManager(PluginManager *p) { plugins = p; } function PluginManager (line 414) | PluginManager *getPluginManager() { return plugins; } FILE: codon/cir/llvm/native/native.cpp type codon (line 13) | namespace codon { type ir (line 14) | namespace ir { function getNativeTarget (line 16) | std::unique_ptr getNativeTarget(const llvm::Triple &triple) { class ArchNativePass (line 83) | class ArchNativePass : public llvm::PassInfoMixin { method ArchNativePass (line 89) | explicit ArchNativePass(const std::string &cpu = "", const std::st... method run (line 92) | llvm::PreservedAnalyses run(llvm::Function &F, llvm::FunctionAnaly... function addNativeLLVMPasses (line 103) | void addNativeLLVMPasses(llvm::PassBuilder *pb) { FILE: codon/cir/llvm/native/native.h function namespace (line 7) | namespace codon { FILE: codon/cir/llvm/native/targets/aarch64.cpp type codon (line 7) | namespace codon { type ir (line 8) | namespace ir { function join (line 10) | std::string join(const T &v, const std::string &delim = ",") { FILE: codon/cir/llvm/native/targets/aarch64.h function namespace (line 7) | namespace codon { FILE: codon/cir/llvm/native/targets/arm.cpp type codon (line 7) | namespace codon { type ir (line 8) | namespace ir { function join (line 10) | std::string join(const T &v, const std::string &delim = ",") { function getARMSubArchVersionNumber (line 20) | int getARMSubArchVersionNumber(const llvm::Triple &triple) { function isARMMProfile (line 25) | bool isARMMProfile(const llvm::Triple &triple) { function isARMBigEndian (line 30) | bool isARMBigEndian(const llvm::Triple &triple) { function isARMAProfile (line 35) | bool isARMAProfile(const llvm::Triple &triple) { function isARMEABIBareMetal (line 40) | bool isARMEABIBareMetal(const llvm::Triple &triple) { function useAAPCSForMachO (line 59) | bool useAAPCSForMachO(const llvm::Triple &triple) { type FloatABI (line 65) | enum FloatABI { Invalid, Hard, Soft, SoftFP } function FloatABI (line 67) | FloatABI getDefaultFloatABI(const llvm::Triple &triple) { function FloatABI (line 140) | FloatABI getARMFloatABI(const llvm::Triple &triple) { function getLLVMArchKindForARM (line 153) | llvm::ARM::ArchKind getLLVMArchKindForARM(llvm::StringRef cpu, llvm:... function getLLVMArchSuffixForARM (line 159) | llvm::StringRef getLLVMArchSuffixForARM(llvm::StringRef cpu, llvm::S... function hasIntegerMVE (line 167) | bool hasIntegerMVE(const std::vector &F) { FILE: codon/cir/llvm/native/targets/arm.h function namespace (line 7) | namespace codon { FILE: codon/cir/llvm/native/targets/target.h function namespace (line 10) | namespace codon { FILE: codon/cir/llvm/native/targets/x86.cpp type codon (line 5) | namespace codon { type ir (line 6) | namespace ir { function join (line 8) | std::string join(const T &v, const std::string &delim = ",") { FILE: codon/cir/llvm/native/targets/x86.h function namespace (line 7) | namespace codon { FILE: codon/cir/llvm/optimize.cpp type codon (line 15) | namespace codon { type ir (line 16) | namespace ir { function getTargetMachine (line 28) | std::unique_ptr function getTargetMachine (line 45) | std::unique_ptr function applyDebugTransformations (line 65) | void applyDebugTransformations(llvm::Module *module, bool debug, boo... function applyFastMathTransformations (line 93) | void applyFastMathTransformations(llvm::Module *module) { type AllocInfo (line 114) | struct AllocInfo { method AllocInfo (line 119) | AllocInfo(std::vector allocators, const std::string &... method getFixedArg (line 123) | static bool getFixedArg(llvm::CallBase &cb, uint64_t &size, unsign... method isAlloc (line 135) | bool isAlloc(const llvm::Value *value) { method isRealloc (line 143) | bool isRealloc(const llvm::Value *value) { method isFree (line 151) | bool isFree(const llvm::Value *value) { method isNeverEqualToUnescapedAlloc (line 172) | bool isNeverEqualToUnescapedAlloc(llvm::Value *value, llvm::Instru... method isAllocSiteRemovable (line 183) | bool isAllocSiteRemovable(llvm::Instruction *ai, method isAllocSiteDemotable (line 281) | bool isAllocSiteDemotable(llvm::Instruction *ai, uint64_t &size, method isAllocSiteHoistable (line 398) | bool isAllocSiteHoistable(llvm::Instruction *ai, llvm::Loop &loop, type AllocationRemover (line 576) | struct AllocationRemover : public llvm::PassInfoMixin allocators = {... method processLoop (line 698) | bool processLoop(llvm::Loop &loop, llvm::LoopInfo &loops, llvm::Cy... method run (line 773) | llvm::PreservedAnalyses run(llvm::Function &F, llvm::FunctionAnaly... type AllocationAutoFree (line 788) | struct AllocationAutoFree : public llvm::PassInfoMixin function generateDummyNames (line 35) | std::vector function translateArgs (line 45) | std::vector function Func (line 159) | Func *Module::getOrRealizeMethod(types::Type *parent, const std::str... function Func (line 180) | Func *Module::getOrRealizeFunc(const std::string &funcName, function Value (line 344) | Value *Module::getInt(int64_t v) { return Nr(v, getIntType... function Value (line 346) | Value *Module::getFloat(double v) { return Nr(v, getFloa... function Value (line 348) | Value *Module::getBool(bool v) { return Nr(v, getBoolType... function Value (line 350) | Value *Module::getString(std::string v) { FILE: codon/cir/module.h function namespace (line 18) | namespace codon { function store (line 491) | void store(Value *v) { function store (line 497) | void store(Var *v) { function ostream_formatter (line 508) | struct fmt::formatter : fmt::ostream_formatter {} FILE: codon/cir/pyextension.h function namespace (line 11) | namespace codon { FILE: codon/cir/transform/cleanup/canonical.cpp type codon (line 16) | namespace codon { type ir (line 17) | namespace ir { type transform (line 18) | namespace transform { type cleanup (line 19) | namespace cleanup { type NodeRanker (line 21) | struct NodeRanker : public util::Operator { method hash_combine (line 35) | void hash_combine(const T &v) { method preHook (line 40) | void preHook(Node *node) { method Rank (line 52) | Rank getRank() { function getRank (line 57) | NodeRanker::Rank getRank(Node *node) { function isCommutativeOp (line 63) | bool isCommutativeOp(Func *fn) { function isAssociativeOp (line 68) | bool isAssociativeOp(Func *fn) { function isDistributiveOp (line 73) | bool isDistributiveOp(Func *fn) { function isInequalityOp (line 78) | bool isInequalityOp(Func *fn) { type CanonOpChain (line 86) | struct CanonOpChain : public RewriteRule { method extractAssociativeOpChain (line 87) | static void extractAssociativeOpChain(Value *v, const std::str... method orderOperands (line 99) | static void orderOperands(std::vector &operands) { method visit (line 112) | void visit(CallInstr *v) override { type CanonInequality (line 147) | struct CanonInequality : public RewriteRule { method visit (line 148) | void visit(CallInstr *v) override { type CanonAddMul (line 188) | struct CanonAddMul : public RewriteRule { method varMatch (line 189) | static bool varMatch(Value *a, Value *b) { method Func (line 195) | static Func *getOp(Value *v) { method Value (line 200) | static Value *addMul(Value *a, Value *b, Value *x) { method visit (line 225) | void visit(CallInstr *v) override { type CanonConstSub (line 277) | struct CanonConstSub : public RewriteRule { method visit (line 278) | void visit(CallInstr *v) override { FILE: codon/cir/transform/cleanup/canonical.h function namespace (line 8) | namespace codon { FILE: codon/cir/transform/cleanup/dead_code.cpp type codon (line 8) | namespace codon { type ir (line 9) | namespace ir { type transform (line 10) | namespace transform { type cleanup (line 11) | namespace cleanup { function BoolConst (line 13) | BoolConst *boolConst(Value *v) { return cast(v); } function IntConst (line 15) | IntConst *intConst(Value *v) { return cast(v); } FILE: codon/cir/transform/cleanup/dead_code.h function namespace (line 7) | namespace codon { FILE: codon/cir/transform/cleanup/global_demote.cpp type codon (line 5) | namespace codon { type ir (line 6) | namespace ir { type transform (line 7) | namespace transform { type cleanup (line 8) | namespace cleanup { type GetUsedGlobals (line 10) | struct GetUsedGlobals : public util::Operator { method preHook (line 12) | void preHook(Node *v) override { FILE: codon/cir/transform/cleanup/global_demote.h function namespace (line 7) | namespace codon { FILE: codon/cir/transform/cleanup/replacer.cpp type codon (line 11) | namespace codon { type ir (line 12) | namespace ir { type transform (line 13) | namespace transform { type cleanup (line 14) | namespace cleanup { FILE: codon/cir/transform/cleanup/replacer.h function namespace (line 7) | namespace codon { FILE: codon/cir/transform/folding/const_fold.cpp type codon (line 14) | namespace codon { type ir (line 15) | namespace ir { type transform (line 16) | namespace transform { type folding (line 17) | namespace folding { function pyDivmod (line 19) | auto pyDivmod(int64_t self, int64_t other) { class IntFloatBinaryRule (line 29) | class IntFloatBinaryRule : public RewriteRule { method IntFloatBinaryRule (line 37) | IntFloatBinaryRule(Func f, std::string magic, types::Type *out, method visit (line 44) | void visit(CallInstr *v) override { class DoubleConstantBinaryRuleExcludeRHSZero (line 75) | class DoubleConstantBinaryRuleExcludeRHSZero method DoubleConstantBinaryRuleExcludeRHSZero (line 78) | DoubleConstantBinaryRuleExcludeRHSZero(Func f, std::string magic, method visit (line 86) | void visit(CallInstr *v) override { function id_val (line 96) | auto id_val(Module *m) { function int_pow (line 103) | int64_t int_pow(int64_t base, int64_t exp) { function To (line 119) | To convert(From x) { return To(x); } function intSingleRule (line 121) | auto intSingleRule(Module *m, Args &&...args) { function intNoOp (line 126) | auto intNoOp(Module *m, std::string magic) { function intDoubleApplyNoOp (line 130) | auto intDoubleApplyNoOp(Module *m, std::string magic) { function intToIntBinary (line 134) | auto intToIntBinary(Module *m, Func f, std::string magic) { function intToIntBinaryNoZeroRHS (line 140) | auto intToIntBinaryNoZeroRHS(Module *m, Func f, std::string magi... function intToBoolBinary (line 146) | auto intToBoolBinary(Module *m, Func f, std::string magic) { function boolToBoolBinary (line 151) | auto boolToBoolBinary(Module *m, Func f, std::string magic) { function floatToFloatBinary (line 156) | auto floatToFloatBinary(Module *m, Func f, std::string magic) { function floatToFloatBinaryNoZeroRHS (line 162) | auto floatToFloatBinaryNoZeroRHS(Module *m, Func f, std::string ... function floatToBoolBinary (line 167) | auto floatToBoolBinary(Module *m, Func f, std::string magic) { function intFloatToFloatBinary (line 173) | auto intFloatToFloatBinary(Module *m, Func f, std::string magic, function intFloatToBoolBinary (line 180) | auto intFloatToBoolBinary(Module *m, Func f, std::string magic) { function intToIntUnary (line 185) | auto intToIntUnary(Module *m, Func f, std::string magic) { function floatToFloatUnary (line 190) | auto floatToFloatUnary(Module *m, Func f, std::string magic) { function boolToBoolUnary (line 195) | auto boolToBoolUnary(Module *m, Func f, std::string magic) { function identityConvert (line 200) | auto identityConvert(Module *m, std::string magic, types::Type *... function typeConvert (line 206) | auto typeConvert(Module *m, std::string magic, types::Type *from... FILE: codon/cir/transform/folding/const_fold.h function namespace (line 11) | namespace codon { FILE: codon/cir/transform/folding/const_prop.cpp type codon (line 10) | namespace codon { type ir (line 11) | namespace ir { type transform (line 12) | namespace transform { type folding (line 13) | namespace folding { function okConst (line 15) | bool okConst(const Value *v) { FILE: codon/cir/transform/folding/const_prop.h function namespace (line 7) | namespace codon { FILE: codon/cir/transform/folding/folding.cpp type codon (line 8) | namespace codon { type ir (line 9) | namespace ir { type transform (line 10) | namespace transform { type folding (line 11) | namespace folding { FILE: codon/cir/transform/folding/folding.h function namespace (line 10) | namespace codon { FILE: codon/cir/transform/folding/rule.h function namespace (line 12) | namespace codon { FILE: codon/cir/transform/lowering/async_for.cpp type codon (line 8) | namespace codon { type ir (line 9) | namespace ir { type transform (line 10) | namespace transform { type lowering (line 11) | namespace lowering { FILE: codon/cir/transform/lowering/async_for.h function namespace (line 7) | namespace codon { FILE: codon/cir/transform/lowering/await.cpp type codon (line 11) | namespace codon { type ir (line 12) | namespace ir { type transform (line 13) | namespace transform { type lowering (line 14) | namespace lowering { function isFuture (line 17) | bool isFuture(const types::Type *type) { function isTask (line 21) | bool isTask(const types::Type *type) { FILE: codon/cir/transform/lowering/await.h function namespace (line 7) | namespace codon { FILE: codon/cir/transform/lowering/imperative.cpp type codon (line 11) | namespace codon { type ir (line 12) | namespace ir { type transform (line 13) | namespace transform { type lowering (line 14) | namespace lowering { function CallInstr (line 16) | CallInstr *getRangeIter(Value *iter) { function Value (line 44) | Value *getListIter(Value *iter) { FILE: codon/cir/transform/lowering/imperative.h function namespace (line 7) | namespace codon { FILE: codon/cir/transform/lowering/pipeline.cpp type codon (line 11) | namespace codon { type ir (line 12) | namespace ir { type transform (line 13) | namespace transform { type lowering (line 14) | namespace lowering { function Value (line 16) | Value *callStage(Module *M, PipelineFlow::Stage *stage, Value *l... function Value (line 24) | Value *convertPipelineToForLoopsHelper(Module *M, BodiedFunc *pa... function Value (line 51) | Value *convertPipelineToForLoops(PipelineFlow *p, BodiedFunc *pa... FILE: codon/cir/transform/lowering/pipeline.h function namespace (line 7) | namespace codon { FILE: codon/cir/transform/manager.cpp type codon (line 31) | namespace codon { type ir (line 32) | namespace ir { type transform (line 33) | namespace transform { FILE: codon/cir/transform/manager.h function namespace (line 16) | namespace codon { function isDisabled (line 177) | bool isDisabled(const std::string &key) { FILE: codon/cir/transform/numpy/expr.cpp type codon (line 7) | namespace codon { type ir (line 8) | namespace ir { type transform (line 9) | namespace transform { type numpy (line 10) | namespace numpy { function isPythonScalar (line 66) | bool isPythonScalar(NumPyType &t) { function Value (line 470) | Value *NumPyExpr::codegenBroadcasts(CodegenContext &C) { function Var (line 503) | Var *NumPyExpr::codegenFusedEval(CodegenContext &C) { function Var (line 597) | Var *NumPyExpr::codegenSequentialEval(CodegenContext &C) { function BroadcastInfo (line 904) | BroadcastInfo NumPyExpr::getBroadcastInfo() { function Value (line 943) | Value *NumPyExpr::codegenScalarExpr( FILE: codon/cir/transform/numpy/forward.cpp type codon (line 5) | namespace codon { type ir (line 6) | namespace ir { type transform (line 7) | namespace transform { type numpy (line 8) | namespace numpy { type GetVars (line 15) | struct GetVars : public util::Operator { method GetVars (line 18) | explicit GetVars(std::unordered_set &vids) : util::Opera... method preHook (line 20) | void preHook(Node *v) override { type OkToForwardPast (line 28) | struct OkToForwardPast : public util::Operator { method OkToForwardPast (line 34) | OkToForwardPast(std::unordered_set &vids, method preHook (line 38) | void preHook(Node *v) override { type GetAllUses (line 61) | struct GetAllUses : public util::Operator { method GetAllUses (line 65) | GetAllUses(Var *var, std::vector &uses) method preHook (line 68) | void preHook(Node *n) override { function canForwardExpressionAlongPath (line 77) | bool canForwardExpressionAlongPath( function canForwardExpression (line 111) | bool canForwardExpression(NumPyOptimizationUnit *expr, Value *ta... function canForwardVariable (line 159) | bool canForwardVariable(AssignInstr *assign, Value *destination,... function ForwardingDAG (line 186) | ForwardingDAG buildForwardingDAG(BodiedFunc *func, RD *rd, CFG *... type UnionFind (line 230) | struct UnionFind { method UnionFind (line 234) | explicit UnionFind(int64_t n) : parent(n), rank(n) { method find (line 241) | int64_t find(int64_t u) { method union_ (line 247) | void union_(int64_t u, int64_t v) { function getForwardingDAGConnectedComponents (line 263) | std::vector function hasCycleHelper (line 295) | bool hasCycleHelper(int64_t v, ForwardingDAG &dag, function hasCycle (line 314) | bool hasCycle(ForwardingDAG &dag, std::vector function NumPyOptimizationUnit (line 359) | NumPyOptimizationUnit *doForwarding(ForwardingDAG &dag, FILE: codon/cir/transform/numpy/indexing.cpp type codon (line 11) | namespace codon { type ir (line 12) | namespace ir { type transform (line 13) | namespace transform { type numpy (line 14) | namespace numpy { type Term (line 18) | struct Term { type Kind (line 19) | enum Kind { INT, VAR, LEN } method Term (line 23) | Term(Kind kind, int64_t val, const VarValue *var) : kind(kind)... method Term (line 25) | static Term valTerm(int64_t v) { return {Kind::INT, v, nullptr... method Term (line 27) | static Term varTerm(VarValue *v) { return {Kind::VAR, 1, v}; } method Term (line 29) | static Term lenTerm(VarValue *v) { return {Kind::LEN, 1, v}; } method negate (line 31) | void negate() { val = -val; } method multiply (line 33) | void multiply(int64_t n) { val *= n; } method combine (line 35) | bool combine(const Term &other) { method zero (line 44) | bool zero() const { return val == 0; } method str (line 46) | std::string str() const { function t2s (line 60) | std::string t2s(const std::vector &terms) { function simplify (line 71) | void simplify(std::vector &terms) { function checkTotal (line 92) | bool checkTotal(const std::vector &terms, bool strict) { function lessCheck (line 111) | bool lessCheck(const std::vector &terms1, const std::vecto... function lessThan (line 125) | bool lessThan(const std::vector &terms1, const std::vector... function lessThanOrEqual (line 129) | bool lessThanOrEqual(const std::vector &terms1, const std:... function replaceLoopVariable (line 133) | std::vector replaceLoopVariable(const std::vector &t... function isArrayType (line 150) | bool isArrayType(types::Type *t, bool dim1 = false) { function isLen (line 164) | bool isLen(Func *f) { function parse (line 169) | bool parse(Value *x, std::vector &terms, bool negate = fal... type IndexInfo (line 219) | struct IndexInfo { method IndexInfo (line 225) | IndexInfo(CallInstr *orig, VarValue *arr, Value *idx, Value *i... type FindArrayIndex (line 229) | struct FindArrayIndex : public util::Operator { method FindArrayIndex (line 232) | FindArrayIndex() : util::Operator(/*childrenFirst=*/true), ind... method handle (line 234) | void handle(CallInstr *v) override { function elideBoundsCheck (line 257) | void elideBoundsCheck(IndexInfo &index) { function isOriginalLoopVar (line 280) | bool isOriginalLoopVar(const Value *loc, ImperativeForFlow *loop, function VarValue (line 316) | const VarValue *isAliasOfLoopVar(const VarValue *v, ImperativeFo... function canElideBoundsCheck (line 329) | bool canElideBoundsCheck(ImperativeForFlow *loop, IndexInfo &index, FILE: codon/cir/transform/numpy/indexing.h function namespace (line 6) | namespace codon { FILE: codon/cir/transform/numpy/numpy.cpp type codon (line 24) | namespace codon { type ir (line 25) | namespace ir { type transform (line 26) | namespace transform { type numpy (line 27) | namespace numpy { function isArrayType (line 41) | bool isArrayType(types::Type *t) { function isUFuncType (line 47) | bool isUFuncType(types::Type *t) { function isNoneType (line 55) | bool isNoneType(types::Type *t, NumPyPrimitiveTypes &T) { function NumPyType (line 79) | NumPyType NumPyType::get(types::Type *t, NumPyPrimitiveTypes &T) { function parse (line 255) | std::unique_ptr parse(Value *v, function Var (line 699) | Var *optimizeHelper(NumPyOptimizationUnit &unit, NumPyExpr *expr... type ExtractArrayExpressions (line 816) | struct ExtractArrayExpressions : public util::Operator { method ExtractArrayExpressions (line 822) | explicit ExtractArrayExpressions(BodiedFunc *func) method extract (line 825) | void extract(Value *v, AssignInstr *assign = nullptr) { method preHook (line 844) | void preHook(Node *n) override { FILE: codon/cir/transform/numpy/numpy.h function namespace (line 15) | namespace codon { FILE: codon/cir/transform/parallel/openmp.cpp type codon (line 15) | namespace codon { type ir (line 16) | namespace ir { type transform (line 17) | namespace transform { type parallel (line 18) | namespace parallel { function warn (line 24) | void warn(const std::string &msg, const Value *v) { type OMPTypes (line 29) | struct OMPTypes { method OMPTypes (line 35) | explicit OMPTypes(Module *M) { function Var (line 43) | Var *getVarFromOutlinedArg(Value *arg) { function Value (line 54) | Value *ptrFromFunc(Func *func) { type ReductionLocks (line 63) | struct ReductionLocks { method Var (line 68) | Var *createLock(Module *M) { method Var (line 84) | Var *getMainLock(Module *M) { method Var (line 90) | Var *getCritLock(Module *M) { type Reduction (line 97) | struct Reduction { type Kind (line 98) | enum Kind { method Value (line 118) | Value *getInitial() { method Value (line 186) | Value *generateNonAtomicReduction(Value *ptr, Value *arg) { method Value (line 224) | Value *generateAtomicReduction(Value *ptr, Value *arg, Var *lo... type ReductionFunction (line 357) | struct ReductionFunction { type ReductionIdentifier (line 363) | struct ReductionIdentifier : public util::Operator { method ReductionIdentifier (line 368) | ReductionIdentifier() method ReductionIdentifier (line 371) | ReductionIdentifier(std::vector shareds, Var *loopVarArg) method isShared (line 375) | bool isShared(Var *shared) { method isSharedDeref (line 385) | bool isSharedDeref(Var *shared, Value *v) { method extractAssociativeOpChain (line 402) | static void extractAssociativeOpChain(Value *v, const std::str... method Reduction (line 415) | Reduction getReductionFromCall(CallInstr *v) { method Reduction (line 505) | Reduction getReduction(Var *shared) { method handle (line 510) | void handle(CallInstr *v) override { type SharedInfo (line 524) | struct SharedInfo { type LoopTemplateReplacer (line 530) | struct LoopTemplateReplacer : public util::Operator { method LoopTemplateReplacer (line 535) | LoopTemplateReplacer(BodiedFunc *parent, CallInstr *replacemen... type ParallelLoopTemplateReplacer (line 539) | struct ParallelLoopTemplateReplacer : public LoopTemplateReplacer { method ParallelLoopTemplateReplacer (line 547) | ParallelLoopTemplateReplacer(BodiedFunc *parent, CallInstr *re... method numReductions (line 552) | unsigned numReductions() { method Value (line 561) | Value *getReductionTuple() { method BodiedFunc (line 571) | BodiedFunc *makeReductionFunc() { method handle (line 598) | void handle(CallInstr *v) override { type ImperativeLoopTemplateReplacer (line 686) | struct ImperativeLoopTemplateReplacer : public ParallelLoopTempl... method ImperativeLoopTemplateReplacer (line 690) | ImperativeLoopTemplateReplacer(BodiedFunc *parent, CallInstr *... method handle (line 696) | void handle(CallInstr *v) override { type TaskLoopReductionVarReplacer (line 804) | struct TaskLoopReductionVarReplacer : public util::Operator { method setupReductionRemap (line 809) | void setupReductionRemap() { method TaskLoopReductionVarReplacer (line 818) | TaskLoopReductionVarReplacer(std::vector reductionArgs,... method preHook (line 824) | void preHook(Node *v) override { method finalize (line 832) | void finalize() { type TaskLoopBodyStubReplacer (line 851) | struct TaskLoopBodyStubReplacer : public util::Operator { method TaskLoopBodyStubReplacer (line 855) | TaskLoopBodyStubReplacer(CallInstr *replacement, std::vector &sharedRedux) { method TaskLoopRoutineStubReplacer (line 933) | TaskLoopRoutineStubReplacer(BodiedFunc *parent, CallInstr *rep... method BodiedFunc (line 943) | BodiedFunc *makeTaskRedInitFunc(Reduction *reduction) { method BodiedFunc (line 958) | BodiedFunc *makeTaskRedCombFunc(Reduction *reduction) { method Value (line 976) | Value *makeTaskRedInput(Reduction *reduction, Value *shar, Val... method handle (line 991) | void handle(VarValue *v) override { method handle (line 1030) | void handle(CallInstr *v) override { type GPULoopBodyStubReplacer (line 1166) | struct GPULoopBodyStubReplacer : public util::Operator { method GPULoopBodyStubReplacer (line 1171) | GPULoopBodyStubReplacer(CallInstr *replacement, Var *loopVar, ... method handle (line 1174) | void handle(CallInstr *v) override { type GPULoopTemplateReplacer (line 1210) | struct GPULoopTemplateReplacer : public LoopTemplateReplacer { method GPULoopTemplateReplacer (line 1213) | GPULoopTemplateReplacer(BodiedFunc *parent, CallInstr *replace... method handle (line 1217) | void handle(CallInstr *v) override { type OpenMPTransformData (line 1230) | struct OpenMPTransformData { function OpenMPTransformData (line 1236) | OpenMPTransformData unpar(T *v) { function OpenMPTransformData (line 1242) | OpenMPTransformData setupOpenMPTransform(T *v, BodiedFunc *paren... type ForkCallData (line 1277) | struct ForkCallData { function ForkCallData (line 1282) | ForkCallData createForkCall(Module *M, OMPTypes &types, Value *r... type CollapseResult (line 1301) | struct CollapseResult { type LoopRange (line 1309) | struct LoopRange { function CollapseResult (line 1317) | CollapseResult collapseLoop(BodiedFunc *parent, ImperativeForFlo... FILE: codon/cir/transform/parallel/openmp.h function namespace (line 7) | namespace codon { FILE: codon/cir/transform/parallel/schedule.cpp type codon (line 11) | namespace codon { type ir (line 12) | namespace ir { type transform (line 13) | namespace transform { type parallel (line 14) | namespace parallel { function getScheduleCode (line 16) | int getScheduleCode(const std::string &schedule = "static", bool... function Value (line 45) | Value *nullIfNeg(Value *v) { FILE: codon/cir/transform/parallel/schedule.h function namespace (line 7) | namespace codon { FILE: codon/cir/transform/pass.cpp type codon (line 7) | namespace codon { type ir (line 8) | namespace ir { type transform (line 9) | namespace transform { FILE: codon/cir/transform/pass.h function namespace (line 8) | namespace codon { FILE: codon/cir/transform/pythonic/dict.cpp type codon (line 11) | namespace codon { type ir (line 12) | namespace ir { type transform (line 13) | namespace transform { type pythonic (line 14) | namespace pythonic { type GetCall (line 17) | struct GetCall { function GetCall (line 31) | GetCall analyzeGet(CallInstr *call) { FILE: codon/cir/transform/pythonic/dict.h function namespace (line 7) | namespace codon { FILE: codon/cir/transform/pythonic/generator.cpp type codon (line 11) | namespace codon { type ir (line 12) | namespace ir { type transform (line 13) | namespace transform { type pythonic (line 14) | namespace pythonic { function isSum (line 16) | bool isSum(Func *f) { function isAny (line 21) | bool isAny(Func *f) { function isAll (line 26) | bool isAll(Func *f) { type GeneratorSumTransformer (line 32) | struct GeneratorSumTransformer : public util::Operator { method GeneratorSumTransformer (line 36) | explicit GeneratorSumTransformer(Var *accumulator) method handle (line 39) | void handle(YieldInstr *v) override { method handle (line 62) | void handle(ReturnInstr *v) override { method handle (line 73) | void handle(YieldInInstr *v) override { valid = false; } type GeneratorAnyAllTransformer (line 77) | struct GeneratorAnyAllTransformer : public util::Operator { method GeneratorAnyAllTransformer (line 81) | explicit GeneratorAnyAllTransformer(bool any) method handle (line 84) | void handle(YieldInstr *v) override { method handle (line 101) | void handle(ReturnInstr *v) override { method handle (line 114) | void handle(YieldInInstr *v) override { valid = false; } function Func (line 117) | Func *genToSum(BodiedFunc *gen, types::Type *startType, types::T... function Func (line 171) | Func *genToAnyAll(BodiedFunc *gen, bool any) { FILE: codon/cir/transform/pythonic/generator.h function namespace (line 7) | namespace codon { FILE: codon/cir/transform/pythonic/io.cpp type codon (line 10) | namespace codon { type ir (line 11) | namespace ir { type transform (line 12) | namespace transform { type pythonic (line 13) | namespace pythonic { function optimizePrint (line 15) | void optimizePrint(CallInstr *v) { function optimizeWrite (line 56) | void optimizeWrite(CallInstr *v) { FILE: codon/cir/transform/pythonic/io.h function namespace (line 7) | namespace codon { FILE: codon/cir/transform/pythonic/list.cpp type codon (line 10) | namespace codon { type ir (line 11) | namespace ir { type transform (line 12) | namespace transform { type pythonic (line 13) | namespace pythonic { function isList (line 20) | bool isList(Value *v) { return v->getType()->getName().rfind(LIS... function isSlice (line 21) | bool isSlice(Value *v) { return v->getType()->getName() == SLICE; } type ElementHandler (line 37) | struct ElementHandler { method ElementHandler (line 40) | ElementHandler() : vars() {} method doSetup (line 46) | void doSetup(const std::vector &values, SeriesFlow *b... type DefaultHandler (line 56) | struct DefaultHandler : public ElementHandler { method DefaultHandler (line 59) | DefaultHandler(Value *element) : ElementHandler(), element(ele... method setup (line 61) | void setup(SeriesFlow *block, BodiedFunc *parent) override { method Value (line 65) | Value *length(Module *M) override { method Value (line 73) | Value *append(Value *result) override { method get (line 82) | static std::unique_ptr get(Value *v, types::Ty... type SliceHandler (line 89) | struct SliceHandler : public ElementHandler { method SliceHandler (line 93) | SliceHandler(Value *element, Value *slice) method setup (line 96) | void setup(SeriesFlow *block, BodiedFunc *parent) override { method Value (line 100) | Value *length(Module *M) override { method Value (line 110) | Value *append(Value *result) override { method get (line 121) | static std::unique_ptr get(Value *v, types::Ty... type LiteralHandler (line 138) | struct LiteralHandler : public ElementHandler { method LiteralHandler (line 141) | LiteralHandler(std::vector elements) method setup (line 144) | void setup(SeriesFlow *block, BodiedFunc *parent) override { method Value (line 148) | Value *length(Module *M) override { return M->getInt(elements.... method Value (line 150) | Value *append(Value *result) override { method get (line 165) | static std::unique_ptr get(Value *v, types::Ty... type InspectionResult (line 193) | struct InspectionResult { function inspect (line 198) | void inspect(Value *v, InspectionResult &r) { function Value (line 216) | Value *optimize(BodiedFunc *parent, InspectionResult &r) { FILE: codon/cir/transform/pythonic/list.h function namespace (line 7) | namespace codon { FILE: codon/cir/transform/pythonic/str.cpp type codon (line 10) | namespace codon { type ir (line 11) | namespace ir { type transform (line 12) | namespace transform { type pythonic (line 13) | namespace pythonic { type InspectionResult (line 15) | struct InspectionResult { function isString (line 20) | bool isString(Value *v) { function inspect (line 25) | void inspect(Value *v, InspectionResult &r) { FILE: codon/cir/transform/pythonic/str.h function namespace (line 7) | namespace codon { FILE: codon/cir/transform/rewrite.h function namespace (line 8) | namespace codon { FILE: codon/cir/types/types.cpp type codon (line 17) | namespace codon { type ir (line 18) | namespace ir { type types (line 19) | namespace types { function extractTypes (line 21) | std::vector function Value (line 56) | Value *Type::doConstruct(std::vector args) { function Type (line 115) | Type *RecordType::getMemberType(const std::string &n) const { function Value (line 144) | Value *RefType::doConstruct(std::vector args) { FILE: codon/cir/types/types.h function namespace (line 18) | namespace codon { function ostream_formatter (line 586) | struct fmt::formatter : fmt::ostream_formatter {} FILE: codon/cir/util/cloning.cpp type codon (line 7) | namespace codon { type ir (line 8) | namespace ir { type util (line 9) | namespace util { type GatherLocals (line 11) | struct GatherLocals : public util::Operator { method preHook (line 13) | void preHook(Node *node) override { function Value (line 22) | Value *CloneVisitor::clone(const Value *other, BodiedFunc *cloneTo, function Var (line 64) | Var *CloneVisitor::clone(const Var *other) { FILE: codon/cir/util/cloning.h function class (line 14) | class CloneVisitor : public ConstVisitor { FILE: codon/cir/util/context.h function namespace (line 7) | namespace codon { FILE: codon/cir/util/format.cpp type codon (line 12) | namespace codon { type ir (line 13) | namespace ir { type util (line 14) | namespace util { type NodeFormatter (line 16) | struct NodeFormatter { method NodeFormatter (line 25) | NodeFormatter(const types::Type *type, std::unordered_set ... method NodeFormatter (line 29) | NodeFormatter(const Value *value, std::unordered_set &seen... method NodeFormatter (line 32) | NodeFormatter(const Var *var, std::unordered_set &seenNodes, function escapeString (line 40) | std::string escapeString(const std::string &str) { class FormatVisitor (line 84) | class FormatVisitor : util::ConstVisitor { method FormatVisitor (line 91) | FormatVisitor(std::ostream &os, std::unordered_set &seenNo... method visit (line 96) | void visit(const Module *v) override { method defaultVisit (line 106) | void defaultVisit(const Node *) override { os << "(unknown_node)... method visit (line 108) | void visit(const Var *v) override { method visit (line 115) | void visit(const BodiedFunc *v) override { method visit (line 124) | void visit(const ExternalFunc *v) override { method visit (line 128) | void visit(const InternalFunc *v) override { method visit (line 132) | void visit(const LLVMFunc *v) override { method visit (line 156) | void visit(const VarValue *v) override { method visit (line 159) | void visit(const PointerValue *v) override { method visit (line 164) | void visit(const SeriesFlow *v) override { method visit (line 169) | void visit(const IfFlow *v) override { method visit (line 173) | void visit(const WhileFlow *v) override { method visit (line 177) | void visit(const ForFlow *v) override { method visit (line 182) | void visit(const ImperativeForFlow *v) override { method visit (line 188) | void visit(const TryCatchFlow *v) override { method visit (line 202) | void visit(const PipelineFlow *v) override { method visit (line 214) | void visit(const dsl::CustomFlow *v) override { v->doFormat(os); } method visit (line 216) | void visit(const IntConst *v) override { method visit (line 219) | void visit(const FloatConst *v) override { method visit (line 222) | void visit(const BoolConst *v) override { method visit (line 225) | void visit(const StringConst *v) override { method visit (line 228) | void visit(const dsl::CustomConst *v) override { v->doFormat(os); } method visit (line 230) | void visit(const AssignInstr *v) override { method visit (line 234) | void visit(const ExtractInstr *v) override { method visit (line 238) | void visit(const InsertInstr *v) override { method visit (line 242) | void visit(const CallInstr *v) override { method visit (line 247) | void visit(const StackAllocInstr *v) override { method visit (line 251) | void visit(const TypePropertyInstr *v) override { method visit (line 263) | void visit(const YieldInInstr *v) override { method visit (line 266) | void visit(const TernaryInstr *v) override { method visit (line 270) | void visit(const BreakInstr *v) override { method visit (line 273) | void visit(const ContinueInstr *v) override { method visit (line 276) | void visit(const ReturnInstr *v) override { method visit (line 279) | void visit(const YieldInstr *v) override { method visit (line 282) | void visit(const AwaitInstr *v) override { method visit (line 286) | void visit(const ThrowInstr *v) override { method visit (line 289) | void visit(const FlowInstr *v) override { method visit (line 293) | void visit(const dsl::CustomInstr *v) override { v->doFormat(os); } method visit (line 295) | void visit(const types::IntType *v) override { method visit (line 298) | void visit(const types::FloatType *v) override { method visit (line 301) | void visit(const types::Float32Type *v) override { method visit (line 304) | void visit(const types::Float16Type *v) override { method visit (line 307) | void visit(const types::BFloat16Type *v) override { method visit (line 310) | void visit(const types::Float128Type *v) override { method visit (line 313) | void visit(const types::BoolType *v) override { method visit (line 316) | void visit(const types::ByteType *v) override { method visit (line 319) | void visit(const types::VoidType *v) override { method visit (line 322) | void visit(const types::RecordType *v) override { method visit (line 333) | void visit(const types::RefType *v) override { method visit (line 337) | void visit(const types::FuncType *v) override { method visit (line 343) | void visit(const types::OptionalType *v) override { method visit (line 347) | void visit(const types::PointerType *v) override { method visit (line 351) | void visit(const types::GeneratorType *v) override { method visit (line 355) | void visit(const types::IntNType *v) override { method visit (line 359) | void visit(const types::VectorType *v) override { method visit (line 363) | void visit(const types::UnionType *v) override { method visit (line 368) | void visit(const dsl::types::CustomType *v) override { v->doForm... method format (line 370) | void format(const Node *n) { method format (line 377) | void format(const types::Type *t, bool canShowFull = false) { method format (line 389) | void format(const Value *t) { method format (line 402) | void format(const Var *t, bool canShowFull = false) { method NodeFormatter (line 415) | NodeFormatter makeFormatter(const types::Type *node, bool canSho... method NodeFormatter (line 420) | NodeFormatter makeFormatter(const Value *node) { method NodeFormatter (line 423) | NodeFormatter makeFormatter(const Var *node, bool canShowFull = ... method makeFormatters (line 429) | std::vector makeFormatters(It begin, It end) { method makeFormatters (line 438) | std::vector makeFormatters(It begin, It end, bool... function format (line 460) | std::string format(const Node *node) { type fmt::formatter (line 481) | struct fmt::formatter : ostream_formatte... FILE: codon/cir/util/format.h function namespace (line 9) | namespace codon { FILE: codon/cir/util/inlining.cpp type codon (line 11) | namespace codon { type ir (line 12) | namespace ir { type util (line 13) | namespace util { class ReturnVerifier (line 17) | class ReturnVerifier : public util::Operator { method handle (line 21) | void handle(ReturnInstr *v) { class ReturnReplacer (line 46) | class ReturnReplacer : public util::Operator { method ReturnReplacer (line 54) | ReturnReplacer(Value *implicitLoop, Var *var, bool aggressive, u... method handle (line 57) | void handle(ReturnInstr *v) { function InlineResult (line 72) | InlineResult inlineFunction(Func *func, std::vector args,... function InlineResult (line 130) | InlineResult inlineCall(CallInstr *v, bool aggressive) { FILE: codon/cir/util/inlining.h function namespace (line 7) | namespace codon { FILE: codon/cir/util/irtools.cpp type codon (line 7) | namespace codon { type ir (line 8) | namespace ir { type util (line 9) | namespace util { function hasAttribute (line 11) | bool hasAttribute(const Func *func, const std::string &attribute) { function isStdlibFunc (line 18) | bool isStdlibFunc(const Func *func, const std::string &submodule) { function CallInstr (line 26) | CallInstr *call(Func *func, const std::vector &args) { function isCallOf (line 31) | bool isCallOf(const Value *value, const std::string &name, function isCallOf (line 63) | bool isCallOf(const Value *value, const std::string &name, int num... function isMagicMethodCall (line 84) | bool isMagicMethodCall(const Value *value) { function Value (line 103) | Value *makeTuple(const std::vector &args, Module *M) { function Var (line 119) | Var *makeVar(Value *x, SeriesFlow *flow, BodiedFunc *parent, bool ... function Value (line 139) | Value *alloc(types::Type *type, Value *count) { function Value (line 145) | Value *alloc(types::Type *type, int64_t count) { function Var (line 150) | Var *getVar(Value *x) { function Var (line 161) | const Var *getVar(const Value *x) { function Func (line 172) | Func *getFunc(Value *x) { function Func (line 181) | const Func *getFunc(const Value *x) { function Value (line 190) | Value *ptrLoad(Value *ptr) { function Value (line 197) | Value *ptrStore(Value *ptr, Value *val) { function Value (line 206) | Value *tupleGet(Value *tuple, unsigned index) { function Value (line 211) | Value *tupleStore(Value *tuple, unsigned index, Value *val) { function BodiedFunc (line 222) | BodiedFunc *getStdlibFunc(Value *x, const std::string &name, function BodiedFunc (line 234) | const BodiedFunc *getStdlibFunc(const Value *x, const std::string ... function setReturnType (line 250) | void setReturnType(Func *func, types::Type *rType) { FILE: codon/cir/util/irtools.h function namespace (line 7) | namespace codon { FILE: codon/cir/util/iterators.h function namespace (line 9) | namespace codon { FILE: codon/cir/util/matching.cpp type codon (line 25) | namespace codon { type ir (line 26) | namespace ir { type util (line 27) | namespace util { class MatchVisitor (line 29) | class MatchVisitor : public util::ConstVisitor { method MatchVisitor (line 39) | explicit MatchVisitor(bool checkName = false, bool varIdMatch = ... method handle (line 43) | void handle(const Var *x, const Var *y) { result = compareVars(x... method handle (line 46) | void handle(const Func *x, const Func *y) {} method handle (line 48) | void handle(const BodiedFunc *x, const BodiedFunc *y) { method handle (line 55) | void handle(const ExternalFunc *x, const ExternalFunc *y) { method handle (line 59) | void handle(const InternalFunc *x, const InternalFunc *y) { method handle (line 63) | void handle(const LLVMFunc *x, const LLVMFunc *y) { method handle (line 80) | void handle(const Value *x, const Value *y) {} method handle (line 82) | void handle(const VarValue *x, const VarValue *y) { method handle (line 86) | void handle(const PointerValue *x, const PointerValue *y) { method handle (line 91) | void handle(const Flow *x, const Flow *y) {} method handle (line 93) | void handle(const SeriesFlow *x, const SeriesFlow *y) { method handle (line 98) | void handle(const IfFlow *x, const IfFlow *y) { method handle (line 105) | void handle(const WhileFlow *x, const WhileFlow *y) { method handle (line 109) | void handle(const ForFlow *x, const ForFlow *y) { method handle (line 114) | void handle(const ImperativeForFlow *x, const ImperativeForFlow ... method handle (line 120) | void handle(const TryCatchFlow *x, const TryCatchFlow *y) { method handle (line 132) | void handle(const PipelineFlow *x, const PipelineFlow *y) { method handle (line 142) | void handle(const dsl::CustomFlow *x, const dsl::CustomFlow *y) { method handle (line 147) | void handle(const IntConst *x, const IntConst *y) { method handle (line 151) | void handle(const FloatConst *x, const FloatConst *y) { method handle (line 155) | void handle(const BoolConst *x, const BoolConst *y) { method handle (line 159) | void handle(const StringConst *x, const StringConst *y) { method handle (line 163) | void handle(const dsl::CustomConst *x, const dsl::CustomConst *y) { method handle (line 168) | void handle(const AssignInstr *x, const AssignInstr *y) { method handle (line 172) | void handle(const ExtractInstr *x, const ExtractInstr *y) { method handle (line 176) | void handle(const InsertInstr *x, const InsertInstr *y) { method handle (line 181) | void handle(const CallInstr *x, const CallInstr *y) { method handle (line 187) | void handle(const StackAllocInstr *x, const StackAllocInstr *y) { method handle (line 191) | void handle(const TypePropertyInstr *x, const TypePropertyInstr ... method handle (line 196) | void handle(const YieldInInstr *x, const YieldInInstr *y) { method handle (line 200) | void handle(const TernaryInstr *x, const TernaryInstr *y) { method handle (line 206) | void handle(const BreakInstr *x, const BreakInstr *y) { method handle (line 210) | void handle(const ContinueInstr *x, const ContinueInstr *y) { method handle (line 214) | void handle(const ReturnInstr *x, const ReturnInstr *y) { method handle (line 218) | void handle(const YieldInstr *x, const YieldInstr *y) { method handle (line 222) | void handle(const AwaitInstr *x, const AwaitInstr *y) { method handle (line 228) | void handle(const ThrowInstr *x, const ThrowInstr *y) { method handle (line 232) | void handle(const FlowInstr *x, const FlowInstr *y) { method handle (line 237) | void handle(const dsl::CustomInstr *x, const dsl::CustomInstr *y) { method process (line 241) | bool process(const Node *x, const Node *y) const { method compareVars (line 260) | bool compareVars(const Var *x, const Var *y) const { method compareFuncs (line 265) | bool compareFuncs(const Func *x, const Func *y) const { function match (line 286) | bool match(Node *a, Node *b, bool checkNames, bool varIdMatch) { FILE: codon/cir/util/matching.h function namespace (line 7) | namespace codon { FILE: codon/cir/util/operator.h function virtual (line 52) | virtual void preHook(Node *node) {} function virtual (line 57) | virtual void postHook(Node *node) {} FILE: codon/cir/util/outlining.cpp type codon (line 13) | namespace codon { type ir (line 14) | namespace ir { type util (line 15) | namespace util { type OutlineReplacer (line 17) | struct OutlineReplacer : public Operator { method OutlineReplacer (line 23) | OutlineReplacer(Module *M, std::unordered_set &modVars, method postHook (line 29) | void postHook(Node *node) override { method Var (line 35) | Var *mappedVar(Var *v) { method replaceOutFlowWithReturn (line 46) | void replaceOutFlowWithReturn(InstrType *v) { method handle (line 58) | void handle(ReturnInstr *v) override { replaceOutFlowWithReturn(... method handle (line 60) | void handle(BreakInstr *v) override { replaceOutFlowWithReturn(v... method handle (line 62) | void handle(ContinueInstr *v) override { replaceOutFlowWithRetur... method handle (line 66) | void handle(VarValue *v) override { method handle (line 78) | void handle(PointerValue *v) override { method handle (line 90) | void handle(AssignInstr *v) override { type Outliner (line 102) | struct Outliner : public Operator { method Outliner (line 119) | Outliner(BodiedFunc *parent, SeriesFlow *flowRegion, method isEnclosingLoopInRegion (line 127) | bool isEnclosingLoopInRegion(id_t loopId = -1) { method handle (line 142) | void handle(WhileFlow *v) override { method handle (line 147) | void handle(ForFlow *v) override { method handle (line 152) | void handle(ImperativeForFlow *v) override { method handle (line 157) | void handle(ReturnInstr *v) override { method handle (line 162) | void handle(BreakInstr *v) override { method handle (line 168) | void handle(ContinueInstr *v) override { method handle (line 174) | void handle(YieldInstr *v) override { method handle (line 179) | void handle(AwaitInstr *v) override { method handle (line 184) | void handle(YieldInInstr *v) override { method handle (line 189) | void handle(StackAllocInstr *v) override { method handle (line 194) | void handle(AssignInstr *v) override { method handle (line 203) | void handle(PointerValue *v) override { method visit (line 212) | void visit(SeriesFlow *v) override { method visit (line 234) | void visit(BodiedFunc *v) override { method preHook (line 241) | void preHook(Node *node) override { method getPrivateVars (line 253) | std::unordered_set getPrivateVars() { method getSharedVars (line 263) | std::unordered_set getSharedVars() { method getModVars (line 273) | std::unordered_set getModVars() { method OutlineResult (line 285) | OutlineResult outline(bool allowOutflows = true) { function OutlineResult (line 391) | OutlineResult outlineRegion(BodiedFunc *parent, SeriesFlow *series, function OutlineResult (line 402) | OutlineResult outlineRegion(BodiedFunc *parent, SeriesFlow *series... FILE: codon/cir/util/outlining.h function namespace (line 7) | namespace codon { FILE: codon/cir/util/packs.h function namespace (line 7) | namespace codon { FILE: codon/cir/util/side_effect.cpp type codon (line 6) | namespace codon { type ir (line 7) | namespace ir { type util (line 8) | namespace util { FILE: codon/cir/util/side_effect.h function namespace (line 7) | namespace codon { FILE: codon/cir/util/visitor.cpp type codon (line 7) | namespace codon { type ir (line 8) | namespace ir { type util (line 9) | namespace util { FILE: codon/cir/util/visitor.h function namespace (line 12) | namespace codon { FILE: codon/cir/value.cpp type codon (line 8) | namespace codon { type ir (line 9) | namespace ir { function Value (line 13) | Value *Value::operator==(Value &other) { function Value (line 17) | Value *Value::operator!=(Value &other) { function Value (line 21) | Value *Value::operator<(Value &other) { function Value (line 25) | Value *Value::operator>(Value &other) { function Value (line 29) | Value *Value::operator<=(Value &other) { function Value (line 33) | Value *Value::operator>=(Value &other) { function Value (line 37) | Value *Value::operator+() { return doUnaryOp(Module::POS_MAGIC_NAME); } function Value (line 39) | Value *Value::operator-() { return doUnaryOp(Module::NEG_MAGIC_NAME); } function Value (line 41) | Value *Value::operator~() { return doUnaryOp(Module::INVERT_MAGIC_NA... function Value (line 43) | Value *Value::operator+(Value &other) { function Value (line 47) | Value *Value::operator-(Value &other) { function Value (line 51) | Value *Value::operator*(Value &other) { function Value (line 55) | Value *Value::matMul(Value &other) { function Value (line 59) | Value *Value::trueDiv(Value &other) { function Value (line 63) | Value *Value::operator/(Value &other) { function Value (line 67) | Value *Value::operator%(Value &other) { function Value (line 71) | Value *Value::pow(Value &other) { return doBinaryOp(Module::POW_MAGI... function Value (line 73) | Value *Value::operator<<(Value &other) { function Value (line 77) | Value *Value::operator>>(Value &other) { function Value (line 81) | Value *Value::operator&(Value &other) { function Value (line 85) | Value *Value::operator|(Value &other) { function Value (line 89) | Value *Value::operator^(Value &other) { function Value (line 93) | Value *Value::operator||(Value &other) { function Value (line 98) | Value *Value::operator&&(Value &other) { function Value (line 103) | Value *Value::operator[](Value &other) { function Value (line 107) | Value *Value::toInt() { return doUnaryOp(Module::INT_MAGIC_NAME); } function Value (line 109) | Value *Value::toFloat() { return doUnaryOp(Module::FLOAT_MAGIC_NAME); } function Value (line 111) | Value *Value::toBool() { return doUnaryOp(Module::BOOL_MAGIC_NAME); } function Value (line 113) | Value *Value::toStr() { return doUnaryOp(Module::REPR_MAGIC_NAME); } function Value (line 115) | Value *Value::len() { return doUnaryOp(Module::LEN_MAGIC_NAME); } function Value (line 117) | Value *Value::iter() { return doUnaryOp(Module::ITER_MAGIC_NAME); } function Value (line 119) | Value *Value::doUnaryOp(const std::string &name) { function Value (line 131) | Value *Value::doBinaryOp(const std::string &name, Value &other) { function Value (line 143) | Value *Value::doCall(const std::vector &args) { FILE: codon/cir/value.h function namespace (line 9) | namespace codon { function virtual (line 115) | virtual int doReplaceUsedValue(id_t id, Value *newValue) { return 0; } FILE: codon/cir/var.cpp type codon (line 7) | namespace codon { type ir (line 8) | namespace ir { FILE: codon/cir/var.h function namespace (line 16) | namespace codon { function virtual (line 107) | virtual int doReplaceUsedValue(id_t id, Value *newValue) { return 0; } function virtual (line 109) | virtual std::vector doGetUsedTypes() const { return {type... function virtual (line 113) | virtual int doReplaceUsedVariable(id_t id, Var *newVar) { return 0; } function Var (line 132) | Var *getVar() { return val; } function Var (line 134) | const Var *getVar() const { return val; } function setVar (line 137) | void setVar(Var *v) { val = v; } function override (line 142) | const override { return {val}; } function Var (line 172) | Var *getVar() { return val; } function Var (line 174) | const Var *getVar() const { return val; } function setVar (line 177) | void setVar(Var *v) { val = v; } function setFields (line 183) | void setFields(std::vector f) { fields = std::move(f); } function override (line 188) | const override { return {val}; } FILE: codon/compiler/compiler.cpp type codon (line 15) | namespace codon { function getPassManagerInit (line 17) | ir::transform::PassManager::Init getPassManagerInit(Compiler::Mode mod... FILE: codon/compiler/compiler.h function namespace (line 17) | namespace codon { FILE: codon/compiler/debug_listener.cpp type codon (line 11) | namespace codon { function makeBacktrace (line 13) | std::string FILE: codon/compiler/debug_listener.h function namespace (line 12) | namespace codon { function class (line 56) | class DebugPlugin : public llvm::orc::ObjectLinkingLayer::Plugin { FILE: codon/compiler/engine.cpp type codon (line 8) | namespace codon { type jit (line 9) | namespace jit { FILE: codon/compiler/engine.h function namespace (line 11) | namespace codon { FILE: codon/compiler/error.cpp type codon (line 5) | namespace codon { type error (line 42) | namespace error { function E (line 52) | void E(llvm::Error &&error) { throw exc::ParserException(std::move(e... type exc (line 56) | namespace exc { FILE: codon/compiler/error.h function namespace (line 13) | namespace codon { FILE: codon/compiler/jit.cpp type codon (line 15) | namespace codon { type jit (line 16) | namespace jit { function collectExecutableStmts (line 38) | void collectExecutableStmts(ast::Stmt *s, ast::SuiteStmt *final) { function buildKey (line 266) | std::string buildKey(const std::string &name, const std::vector pluginError(const std::string &msg) { FILE: codon/dsl/plugins.h function namespace (line 15) | namespace codon { FILE: codon/parser/ast/attr.cpp type codon::ast (line 5) | namespace codon::ast {} FILE: codon/parser/ast/attr.h function namespace (line 5) | namespace codon::ast { FILE: codon/parser/ast/error.h function namespace (line 20) | namespace codon { function front (line 63) | struct ParserErrors { function explicit (line 82) | explicit ParserErrors(const ErrorMessage &msg) : errors{Backtrace{{msg}}} FILE: codon/parser/ast/expr.cpp type codon::ast (line 30) | namespace codon::ast { function Param (line 72) | Param Param::clone(bool clean) const { function Expr (line 275) | Expr *GeneratorExpr::getFinalExpr() { function Stmt (line 303) | Stmt *GeneratorExpr::getFinalSuite() const { return loops; } function Stmt (line 304) | Stmt **GeneratorExpr::getFinalStmt() { function Pipe (line 376) | Pipe Pipe::clone(bool clean) const { return {op, ast::clone(expr, clea... function CallArg (line 408) | CallArg CallArg::clone(bool clean) const { function isId (line 555) | bool isId(Expr *e, const std::string &s) { function getStaticGeneric (line 560) | types::LiteralKind getStaticGeneric(Expr *e) { type tser (line 603) | namespace tser { FILE: codon/parser/ast/expr.h function namespace (line 16) | namespace codon::ast { type BoolExpr (line 114) | struct BoolExpr type IntExpr (line 130) | struct IntExpr function hasStoredValue (line 135) | bool hasStoredValue() const; type ListExpr (line 273) | struct ListExpr type SetExpr (line 282) | struct SetExpr type DictExpr (line 292) | struct DictExpr type GeneratorExpr (line 302) | struct GeneratorExpr type GeneratorKind (line 304) | enum GeneratorKind { function loopCount (line 318) | int loopCount() const; type UnaryExpr (line 355) | struct UnaryExpr function Expr (line 360) | Expr *getExpr() const { return expr; } type BinaryExpr (line 372) | struct BinaryExpr function setOp (line 378) | void setOp(const std::string &o) { op = o; } function Expr (line 379) | Expr *getLhs() const { return lexpr; } function Expr (line 380) | Expr *getRhs() const { return rexpr; } type ChainBinaryExpr (line 395) | struct ChainBinaryExpr type Pipe (line 405) | struct Pipe { type PipeExpr (line 416) | struct PipeExpr type IndexExpr (line 430) | struct IndexExpr function Expr (line 434) | Expr *getExpr() const { return expr; } function Expr (line 435) | Expr *getIndex() const { return index; } type CallArg (line 443) | struct CallArg function Expr (line 452) | Expr *getExpr() const { return value; } function operator (line 453) | operator Expr *() const { return value; } type CallExpr (line 461) | struct CallExpr function Expr (line 471) | Expr *getExpr() const { return expr; } type DotExpr (line 487) | struct DotExpr function Expr (line 492) | Expr *getExpr() const { return expr; } type SliceExpr (line 506) | struct SliceExpr function Expr (line 510) | Expr *getStart() const { return start; } function Expr (line 511) | Expr *getStop() const { return stop; } function Expr (line 512) | Expr *getStep() const { return step; } type EllipsisExpr (line 523) | struct EllipsisExpr type EllipsisType (line 526) | enum EllipsisType { PIPE, PARTIAL, STANDALONE } type LambdaExpr (line 546) | struct LambdaExpr function Expr (line 550) | Expr *getExpr() const { return expr; } type YieldExpr (line 560) | struct YieldExpr type AwaitExpr (line 569) | struct AwaitExpr function Expr (line 573) | Expr *getExpr() const { return expr; } type AssignExpr (line 587) | struct AssignExpr function Expr (line 591) | Expr *getVar() const { return var; } function Expr (line 592) | Expr *getExpr() const { return expr; } type RangeExpr (line 603) | struct RangeExpr function Expr (line 607) | Expr *getStart() const { return start; } function Expr (line 608) | Expr *getStop() const { return stop; } type StmtExpr (line 622) | struct StmtExpr function Expr (line 628) | Expr *getExpr() const { return expr; } type InstantiateExpr (line 638) | struct InstantiateExpr function Expr (line 644) | Expr *getExpr() const { return expr; } function string_view (line 660) | struct fmt::formatter : fmt::formatter : fmt::formatter items) : items(std::move(items)) {} function T (line 92) | const T &operator[](size_t i) const { return items[i]; } FILE: codon/parser/ast/stmt.cpp type codon::ast (line 22) | namespace codon::ast { function SuiteStmt (line 72) | SuiteStmt *SuiteStmt::wrap(Stmt *s) { function MatchCase (line 225) | MatchCase MatchCase::clone(bool clean) const { class IdSearchVisitor (line 404) | class IdSearchVisitor : public CallbackASTVisitor { method IdSearchVisitor (line 409) | IdSearchVisitor(std::string what) : what(std::move(what)), result(fa... method transform (line 410) | bool transform(Expr *expr) override { method transform (line 418) | bool transform(Stmt *stmt) override { method visit (line 426) | void visit(IdExpr *expr) override { type tser (line 632) | namespace tser { FILE: codon/parser/ast/stmt.h function namespace (line 14) | namespace codon::ast { type ContinueStmt (line 92) | struct ContinueStmt type ExprStmt (line 101) | struct ExprStmt function Expr (line 105) | Expr *getExpr() const { return expr; } type AssignStmt (line 117) | struct AssignStmt type UpdateMode (line 118) | enum UpdateMode { Assign, Update, UpdateAtomic, ThreadLocalAssign } function Expr (line 126) | Expr *getLhs() const { return lhs; } function Expr (line 127) | Expr *getRhs() const { return rhs; } function Expr (line 128) | Expr *getTypeExpr() const { return type; } function setLhs (line 130) | void setLhs(Expr *expr) { lhs = expr; } function setRhs (line 131) | void setRhs(Expr *expr) { rhs = expr; } function isThreadLocal (line 136) | bool isThreadLocal() { return update == ThreadLocalAssign; } function setUpdate (line 137) | void setUpdate() { update = Update; } function setAtomicUpdate (line 138) | void setAtomicUpdate() { update = UpdateAtomic; } function setThreadLocal (line 139) | void setThreadLocal() { update = ThreadLocalAssign; } type DelStmt (line 151) | struct DelStmt function Expr (line 155) | Expr *getExpr() const { return expr; } type PrintStmt (line 165) | struct PrintStmt type ReturnStmt (line 181) | struct ReturnStmt function Expr (line 185) | Expr *getExpr() const { return expr; } type YieldStmt (line 197) | struct YieldStmt function Expr (line 201) | Expr *getExpr() const { return expr; } type AssertStmt (line 213) | struct AssertStmt function Expr (line 217) | Expr *getExpr() const { return expr; } function Expr (line 218) | Expr *getMessage() const { return message; } type WhileStmt (line 232) | struct WhileStmt function Expr (line 237) | Expr *getCond() const { return cond; } function SuiteStmt (line 238) | SuiteStmt *getSuite() const { return suite; } function SuiteStmt (line 239) | SuiteStmt *getElse() const { return elseSuite; } type ForStmt (line 258) | struct ForStmt function Expr (line 267) | Expr *getVar() const { return var; } function Expr (line 268) | Expr *getIter() const { return iter; } function SuiteStmt (line 269) | SuiteStmt *getSuite() const { return suite; } function SuiteStmt (line 270) | SuiteStmt *getElse() const { return elseSuite; } function Expr (line 271) | Expr *getDecorator() const { return decorator; } function setDecorator (line 272) | void setDecorator(Expr *e) { decorator = e; } function setAsync (line 274) | void setAsync() { async = true; } type IfStmt (line 306) | struct IfStmt function Expr (line 310) | Expr *getCond() const { return cond; } function SuiteStmt (line 311) | SuiteStmt *getIf() const { return ifSuite; } function SuiteStmt (line 312) | SuiteStmt *getElse() const { return elseSuite; } type MatchCase (line 324) | struct MatchCase { function SuiteStmt (line 329) | SuiteStmt *getSuite() const { return suite; } type MatchStmt (line 349) | struct MatchStmt function Expr (line 353) | Expr *getExpr() const { return expr; } type ImportStmt (line 373) | struct ImportStmt function Expr (line 379) | Expr *getFrom() const { return from; } function Expr (line 380) | Expr *getWhat() const { return what; } function Expr (line 383) | Expr *getReturnType() const { return ret; } type ExceptStmt (line 402) | struct ExceptStmt function Expr (line 407) | Expr *getException() const { return exc; } function SuiteStmt (line 408) | SuiteStmt *getSuite() const { return suite; } type TryStmt (line 429) | struct TryStmt function SuiteStmt (line 434) | SuiteStmt *getSuite() const { return suite; } function SuiteStmt (line 435) | SuiteStmt *getElse() const { return elseSuite; } function SuiteStmt (line 436) | SuiteStmt *getFinally() const { return finally; } type ThrowStmt (line 450) | struct ThrowStmt function Expr (line 455) | Expr *getExpr() const { return expr; } function Expr (line 456) | Expr *getFrom() const { return from; } type GlobalStmt (line 471) | struct GlobalStmt type FunctionStmt (line 488) | struct FunctionStmt function setName (line 495) | void setName(const std::string &n) { name = n; } function Expr (line 496) | Expr *getReturn() const { return ret; } function SuiteStmt (line 497) | SuiteStmt *getSuite() const { return suite; } function setSuite (line 498) | void setSuite(SuiteStmt *s) { suite = s; } function setDecorators (line 500) | void setDecorators(const std::vector &d) { decorators = d; } function setAsync (line 502) | void setAsync() { async = true; } function addParam (line 503) | void addParam(const Param &p) { items.push_back(p); } function getStarArgs (line 509) | size_t getStarArgs() const; function setDecorators (line 543) | void setDecorators(const std::vector &d) { decorators = d; } type YieldFromStmt (line 566) | struct YieldFromStmt function Expr (line 570) | Expr *getExpr() const { return expr; } type WithStmt (line 580) | struct WithStmt function SuiteStmt (line 587) | SuiteStmt *getSuite() const { return suite; } function setAsync (line 590) | void setAsync() { async = true; } type CustomStmt (line 603) | struct CustomStmt function Expr (line 608) | Expr *getExpr() const { return expr; } function SuiteStmt (line 609) | SuiteStmt *getSuite() const { return suite; } type DirectiveStmt (line 619) | struct DirectiveStmt type AssignMemberStmt (line 636) | struct AssignMemberStmt function Expr (line 641) | Expr *getLhs() const { return lhs; } function Expr (line 643) | Expr *getRhs() const { return rhs; } function Expr (line 644) | Expr *getTypeExpr() const { return type; } type CommentStmt (line 657) | struct CommentStmt function namespace (line 673) | namespace tser { FILE: codon/parser/ast/types/class.cpp type codon::ast::types (line 10) | namespace codon::ast::types { function TypePtr (line 160) | TypePtr ClassType::generalize(int atLevel) const { function TypePtr (line 172) | TypePtr ClassType::instantiate(int atLevel, int *unboundCount, function FuncType (line 336) | FuncType *ClassType::getPartialFunc() const { FILE: codon/parser/ast/types/class.h function namespace (line 11) | namespace codon::ast::types { function string_view (line 90) | struct fmt::formatter FILE: codon/parser/ast/types/function.cpp type codon::ast::types (line 11) | namespace codon::ast::types { function TypePtr (line 44) | TypePtr FuncType::generalize(int atLevel) const { function TypePtr (line 55) | TypePtr FuncType::instantiate(int atLevel, int *unboundCount, function Type (line 198) | Type *FuncType::getRetType() const { return generics[1].type.get(); } function Type (line 202) | Type *FuncType::operator[](size_t i) const { FILE: codon/parser/ast/types/function.h function namespace (line 13) | namespace codon::ast { function namespace (line 17) | namespace codon::ast::types { FILE: codon/parser/ast/types/link.cpp type codon::ast::types (line 11) | namespace codon::ast::types { function TypePtr (line 96) | TypePtr LinkType::generalize(int atLevel) const { function TypePtr (line 119) | TypePtr LinkType::instantiate(int atLevel, int *unboundCount, function Type (line 146) | Type *LinkType::follow() { function LinkType (line 206) | LinkType *LinkType::getLink() { return this; } function FuncType (line 208) | FuncType *LinkType::getFunc() { return kind == Link ? type->getFunc() ... function ClassType (line 210) | ClassType *LinkType::getPartial() { function ClassType (line 214) | ClassType *LinkType::getClass() { return kind == Link ? type->getClass... function StaticType (line 216) | StaticType *LinkType::getStatic() { return kind == Link ? type->getSta... function IntStaticType (line 218) | IntStaticType *LinkType::getIntStatic() { function StrStaticType (line 222) | StrStaticType *LinkType::getStrStatic() { function BoolStaticType (line 226) | BoolStaticType *LinkType::getBoolStatic() { function UnionType (line 230) | UnionType *LinkType::getUnion() { return kind == Link ? type->getUnion... function LinkType (line 232) | LinkType *LinkType::getUnbound() { FILE: codon/parser/ast/types/link.h function namespace (line 13) | namespace codon::ast::types { FILE: codon/parser/ast/types/static.cpp type codon::ast::types (line 12) | namespace codon::ast::types { function Type (line 23) | Type *StaticType::getNonStaticType() const { return cache->findClass(n... function TypePtr (line 42) | TypePtr IntStaticType::generalize(int atLevel) const { function TypePtr (line 48) | TypePtr IntStaticType::instantiate(int atLevel, int *unboundCount, function Expr (line 59) | Expr *IntStaticType::getStaticExpr() const { return cache->N(... function TypePtr (line 78) | TypePtr StrStaticType::generalize(int atLevel) const { function TypePtr (line 84) | TypePtr StrStaticType::instantiate(int atLevel, int *unboundCount, function Expr (line 96) | Expr *StrStaticType::getStaticExpr() const { return cache->NN decltype(ctx.be... FILE: codon/parser/ast/types/union.cpp type codon::ast::types (line 13) | namespace codon::ast::types { function TypePtr (line 65) | TypePtr UnionType::generalize(int atLevel) const { function TypePtr (line 75) | TypePtr UnionType::instantiate(int atLevel, int *unboundCount, FILE: codon/parser/ast/types/union.h function namespace (line 12) | namespace codon::ast::types { FILE: codon/parser/cache.cpp type codon::ast (line 18) | namespace codon::ast { function SrcInfo (line 46) | SrcInfo Cache::generateSrcInfo() { FILE: codon/parser/cache.h function namespace (line 46) | namespace codon { function namespace (line 50) | namespace codon::ast { type Function (line 208) | struct Function { FILE: codon/parser/common.cpp type codon::ast (line 20) | namespace codon::ast { function ImportFile (line 37) | ImportFile IFilesystem::get_root(const path_t &sp) const { function split (line 150) | std::vector split(const std::string &s, char delim) { function escape (line 159) | std::string escape(const std::string &str) { function unescape (line 182) | std::string unescape(const std::string &str) { function escapeFStringBraces (line 223) | std::string escapeFStringBraces(const std::string &str, int start, int... function findStar (line 235) | int findStar(const std::string &s) { function in (line 245) | bool in(const std::string &m, char item) { function in (line 249) | bool in(const std::string &m, const std::string &item) { function startswith (line 253) | size_t startswith(const std::string &str, const std::string &prefix) { function endswith (line 260) | size_t endswith(const std::string &str, const std::string &suffix) { function ltrim (line 268) | void ltrim(std::string &str) { function rtrim (line 272) | void rtrim(std::string &str) { function isdigit (line 279) | bool isdigit(const std::string &str) { return std::ranges::all_of(str,... function library_path (line 286) | std::string library_path() { function getImportFile (line 348) | std::shared_ptr getImportFile(Cache *cache, const std::str... function getMangledClass (line 422) | std::string getMangledClass(const std::string &module, const std::stri... function getMangledFunc (line 432) | std::string getMangledFunc(const std::string &module, const std::strin... function getMangledMethod (line 443) | std::string getMangledMethod(const std::string &module, const std::str... function getMangledVar (line 454) | std::string getMangledVar(const std::string &module, const std::string... FILE: codon/parser/common.h function namespace (line 17) | namespace codon { FILE: codon/parser/ctx.h function namespace (line 16) | namespace codon::ast { FILE: codon/parser/match.cpp type codon::matcher (line 5) | namespace codon::matcher { function match_zero_or_more_t (line 7) | match_zero_or_more_t MAny() { return match_zero_or_more_t(); } function match_startswith_t (line 9) | match_startswith_t MStarts(std::string s) { return match_startswith_t{... function match_endswith_t (line 11) | match_endswith_t MEnds(std::string s) { return match_endswith_t{std::m... function match_contains_t (line 13) | match_contains_t MContains(std::string s) { return match_contains_t{st... function match (line 15) | bool match(const char *c, const char *d) { function match (line 19) | bool match(const char *c, std::string d) { return std::string(c) == d; } function match (line 21) | bool match(std::string c, const char *d) { return std::string(d) == c; } function match (line 23) | bool match(double &a, double b) { function match (line 27) | bool match(std::string s, match_startswith_t m) { function match (line 31) | bool match(std::string s, match_endswith_t m) { function match (line 35) | bool match(std::string s, match_contains_t m) { function match (line 39) | bool match(const char *s, match_startswith_t m) { function match (line 43) | bool match(const char *s, match_endswith_t m) { function match (line 47) | bool match(const char *s, match_contains_t m) { FILE: codon/parser/match.h function args (line 20) | match_or_t(MA... args) : args(std::tuple(args...)) {} type match_ignore_t (line 23) | struct match_ignore_t {} type match_zero_or_more_t (line 25) | struct match_zero_or_more_t {} type match_startswith_t (line 27) | struct match_startswith_t { type match_endswith_t (line 31) | struct match_endswith_t { type match_contains_t (line 35) | struct match_contains_t { FILE: codon/parser/peg/peg.cpp type codon::ast (line 20) | namespace codon::ast { function initParser (line 25) | std::shared_ptr initParser() { function parseCode (line 57) | llvm::Expected parseCode(Cache *cache, const std::string &file, function parseCode (line 90) | llvm::Expected parseCode(Cache *cache, const std::string &file, function parseExpr (line 95) | llvm::Expected> function parseFile (line 104) | llvm::Expected parseFile(Cache *cache, const std::string &file) { function initOpenMPParser (line 113) | std::shared_ptr initOpenMPParser() { function parseOpenMP (line 125) | llvm::Expected> parseOpenMP(Cache *cache, const s... FILE: codon/parser/peg/peg.h function namespace (line 11) | namespace codon::ast { FILE: codon/parser/peg/rules.h function namespace (line 11) | namespace codon::ast { FILE: codon/parser/visitors/doc/doc.cpp type codon::ast (line 16) | namespace codon::ast { function json_escape (line 22) | std::string json_escape(const std::string &str) { function getDocstr (line 149) | std::string getDocstr(Stmt *s) { function isValidName (line 256) | bool isValidName(const std::string &s) { FILE: codon/parser/visitors/doc/doc.h function namespace (line 16) | namespace codon::ast { FILE: codon/parser/visitors/format/format.cpp type codon (line 8) | namespace codon { type ast (line 9) | namespace ast { FILE: codon/parser/visitors/format/format.h function string (line 44) | string renderComment(const char *fmt, Ts &&...args) { function defaultVisit (line 68) | void defaultVisit(Expr *e) override { seqassertn(false, "cannot format {... function defaultVisit (line 69) | void defaultVisit(Stmt *e) override { seqassertn(false, "cannot format {... FILE: codon/parser/visitors/scoping/scoping.cpp type codon::ast (line 27) | namespace codon::ast { function format_as (line 954) | auto format_as(BindingsAttribute::CaptureType c) { FILE: codon/parser/visitors/scoping/scoping.h function namespace (line 16) | namespace codon::ast { type Context (line 48) | struct Context { function ConditionalBlock (line 112) | struct ConditionalBlock { function addError (line 141) | void addError(llvm::Error &&e) { FILE: codon/parser/visitors/translate/translate.cpp type codon::ast (line 20) | namespace codon::ast { class IdVisitor (line 221) | class IdVisitor : public CallbackASTVisitor { method transform (line 225) | bool transform(Expr *expr) override { method transform (line 232) | bool transform(Stmt *stmt) override { method visit (line 239) | void visit(IdExpr *expr) override { ids.insert(expr->getValue()); } FILE: codon/parser/visitors/translate/translate.h function namespace (line 13) | namespace codon::ast { FILE: codon/parser/visitors/translate/translate_ctx.cpp type codon::ast (line 14) | namespace codon::ast { FILE: codon/parser/visitors/translate/translate_ctx.h function namespace (line 15) | namespace codon::ast { type TranslateContext (line 46) | struct TranslateContext FILE: codon/parser/visitors/typecheck/access.cpp type codon::ast (line 16) | namespace codon::ast { function Expr (line 520) | Expr *TypecheckVisitor::getClassMember(DotExpr *expr) { FILE: codon/parser/visitors/typecheck/assign.cpp type codon::ast (line 17) | namespace codon::ast { function Stmt (line 103) | Stmt *TypecheckVisitor::unpackAssignment(Expr *lhs, Expr *rhs) { function Stmt (line 178) | Stmt *TypecheckVisitor::transformAssignment(AssignStmt *stmt, bool mus... function Stmt (line 338) | Stmt *TypecheckVisitor::transformUpdate(AssignStmt *stmt) { FILE: codon/parser/visitors/typecheck/basic.cpp type codon::ast (line 11) | namespace codon::ast { function Expr (line 98) | Expr *TypecheckVisitor::transformInt(IntExpr *expr) { function Expr (line 148) | Expr *TypecheckVisitor::transformFloat(FloatExpr *expr) { FILE: codon/parser/visitors/typecheck/call.cpp type codon::ast (line 13) | namespace codon::ast { function Expr (line 444) | Expr *TypecheckVisitor::callReorderArguments(FuncType *calleeFn, CallE... function Expr (line 990) | Expr *TypecheckVisitor::generatePartialCall(const std::string &mask, FILE: codon/parser/visitors/typecheck/class.cpp type codon::ast (line 16) | namespace codon::ast { function Stmt (line 605) | Stmt *TypecheckVisitor::codegenMagic(const std::string &op, Expr *typE... FILE: codon/parser/visitors/typecheck/collections.cpp type codon::ast (line 10) | namespace codon::ast { function Expr (line 173) | Expr *TypecheckVisitor::transformComprehension(const std::string &type, FILE: codon/parser/visitors/typecheck/cond.cpp type codon::ast (line 8) | namespace codon::ast { function evaluateStaticCondition (line 15) | auto evaluateStaticCondition(Expr *cond, TT ready, TF notReady) { function Stmt (line 164) | Stmt *TypecheckVisitor::transformPattern(Expr *var, Expr *pattern, Stm... FILE: codon/parser/visitors/typecheck/ctx.cpp type codon::ast (line 17) | namespace codon::ast { FILE: codon/parser/visitors/typecheck/ctx.h function namespace (line 16) | namespace codon::ast { FILE: codon/parser/visitors/typecheck/error.cpp type codon::ast (line 8) | namespace codon::ast { FILE: codon/parser/visitors/typecheck/function.cpp type codon::ast (line 17) | namespace codon::ast { function Stmt (line 683) | Stmt *TypecheckVisitor::transformPythonDefinition(const std::string &n... function Stmt (line 719) | Stmt *TypecheckVisitor::transformLLVMDefinition(Stmt *codeStmt) { FILE: codon/parser/visitors/typecheck/import.cpp type codon::ast (line 19) | namespace codon::ast { function Stmt (line 139) | Stmt *TypecheckVisitor::transformSpecialImport(const ImportStmt *stmt) { function Stmt (line 193) | Stmt *TypecheckVisitor::transformCImport(const std::string &name, function Stmt (line 232) | Stmt *TypecheckVisitor::transformCVarImport(const std::string &name, E... function Stmt (line 253) | Stmt *TypecheckVisitor::transformCDLLImport(Expr *dylib, const std::st... function Stmt (line 287) | Stmt *TypecheckVisitor::transformPythonImport(Expr *what, function Stmt (line 341) | Stmt *TypecheckVisitor::transformNewImport(const ImportFile &file) { FILE: codon/parser/visitors/typecheck/infer.cpp type codon::ast (line 22) | namespace codon::ast { function Type (line 32) | Type *TypecheckVisitor::unify(Type *a, Type *b) const { function Stmt (line 47) | Stmt *TypecheckVisitor::inferTypes(Stmt *result, bool isToplevel) { FILE: codon/parser/visitors/typecheck/loops.cpp type codon::ast (line 13) | namespace codon::ast { function Expr (line 221) | Expr *TypecheckVisitor::transformForDecorator(Expr *decorator) { FILE: codon/parser/visitors/typecheck/op.cpp type codon::ast (line 14) | namespace codon::ast { function Expr (line 562) | Expr *TypecheckVisitor::evaluateStaticUnary(const UnaryExpr *expr) { function divMod (line 622) | std::pair divMod(const std::shared_ptr ... function Expr (line 646) | Expr *TypecheckVisitor::evaluateStaticBinary(const BinaryExpr *expr) { function Expr (line 758) | Expr *TypecheckVisitor::transformBinarySimple(const BinaryExpr *expr) { function Expr (line 829) | Expr *TypecheckVisitor::transformBinaryIs(const BinaryExpr *expr) { function Expr (line 922) | Expr *TypecheckVisitor::transformBinaryInplaceMagic(BinaryExpr *expr, ... function Expr (line 953) | Expr *TypecheckVisitor::transformBinaryMagic(const BinaryExpr *expr) { FILE: codon/parser/visitors/typecheck/special.cpp type codon::ast (line 20) | namespace codon::ast { function SuiteStmt (line 72) | SuiteStmt *TypecheckVisitor::generateClassPopulateVTablesAST() { function SuiteStmt (line 108) | SuiteStmt *TypecheckVisitor::generateBaseDerivedDistAST(FuncType *f) { function FunctionStmt (line 141) | FunctionStmt *TypecheckVisitor::generateThunkAST(const FuncType *fp, C... function SuiteStmt (line 203) | SuiteStmt *TypecheckVisitor::generateGetThunkIDAst(types::FuncType *f) { function SuiteStmt (line 269) | SuiteStmt *TypecheckVisitor::generateFunctionCallInternalAST(FuncType ... function SuiteStmt (line 296) | SuiteStmt *TypecheckVisitor::generateUnionNewAST(const FuncType *type) { function SuiteStmt (line 306) | SuiteStmt *TypecheckVisitor::generateUnionTagAST(FuncType *type) { function SuiteStmt (line 320) | SuiteStmt *TypecheckVisitor::generateNamedKeysAST(FuncType *type) { function SuiteStmt (line 331) | SuiteStmt *TypecheckVisitor::generateTupleMulAST(FuncType *type) { function SuiteStmt (line 346) | SuiteStmt *TypecheckVisitor::generateSpecialAst(types::FuncType *type) { function Expr (line 381) | Expr *TypecheckVisitor::transformNamedTuple(CallExpr *expr) { function Expr (line 419) | Expr *TypecheckVisitor::transformFunctoolsPartial(CallExpr *expr) { function Expr (line 437) | Expr *TypecheckVisitor::transformSuperF(CallExpr *expr) { function Expr (line 476) | Expr *TypecheckVisitor::transformSuper() { function Expr (line 529) | Expr *TypecheckVisitor::transformPtr(CallExpr *expr) { function Expr (line 562) | Expr *TypecheckVisitor::transformArray(CallExpr *expr) { function Expr (line 576) | Expr *TypecheckVisitor::transformIsInstance(CallExpr *expr) { function Expr (line 676) | Expr *TypecheckVisitor::transformStaticLen(CallExpr *expr) { function Expr (line 702) | Expr *TypecheckVisitor::transformHasAttr(CallExpr *expr) { function Expr (line 762) | Expr *TypecheckVisitor::transformGetAttr(CallExpr *expr) { function Expr (line 783) | Expr *TypecheckVisitor::transformSetAttr(CallExpr *expr) { function Expr (line 791) | Expr *TypecheckVisitor::transformCompileError(CallExpr *expr) const { function Expr (line 798) | Expr *TypecheckVisitor::transformTupleFn(CallExpr *expr) { function Expr (line 832) | Expr *TypecheckVisitor::transformTypeFn(CallExpr *expr) { function Expr (line 845) | Expr *TypecheckVisitor::transformRealizedFn(CallExpr *expr) { function Expr (line 872) | Expr *TypecheckVisitor::transformStaticPrintFn(CallExpr *expr) const { function Expr (line 883) | Expr *TypecheckVisitor::transformHasRttiFn(const CallExpr *expr) { function Expr (line 894) | Expr *TypecheckVisitor::transformStaticFnCanCall(CallExpr *expr) { function Expr (line 926) | Expr *TypecheckVisitor::transformStaticFnArgHasType(CallExpr *expr) { function Expr (line 940) | Expr *TypecheckVisitor::transformStaticFnArgGetType(CallExpr *expr) { function Expr (line 952) | Expr *TypecheckVisitor::transformStaticFnArgs(CallExpr *expr) { function Expr (line 967) | Expr *TypecheckVisitor::transformStaticFnHasDefault(CallExpr *expr) { function Expr (line 982) | Expr *TypecheckVisitor::transformStaticFnGetDefault(CallExpr *expr) { function Expr (line 994) | Expr *TypecheckVisitor::transformStaticFnWrapCallArgs(CallExpr *expr) { function Expr (line 1027) | Expr *TypecheckVisitor::transformStaticVars(CallExpr *expr) { function Expr (line 1054) | Expr *TypecheckVisitor::transformStaticTupleType(const CallExpr *expr) { function Expr (line 1070) | Expr *TypecheckVisitor::transformStaticFormat(CallExpr *expr) { function Expr (line 1089) | Expr *TypecheckVisitor::transformStaticIntToStr(CallExpr *expr) { FILE: codon/parser/visitors/typecheck/typecheck.cpp type codon::ast (line 21) | namespace codon::ast { function Stmt (line 32) | Stmt *TypecheckVisitor::apply( function Stmt (line 176) | Stmt *TypecheckVisitor::apply(const std::shared_ptr &ctx,... function Expr (line 207) | Expr *TypecheckVisitor::transform(Expr *expr) { return transform(expr,... function Expr (line 210) | Expr *TypecheckVisitor::transform(Expr *expr, bool allowTypes) { function Expr (line 254) | Expr *TypecheckVisitor::transformType(Expr *expr, bool simple) { function Stmt (line 289) | Stmt *TypecheckVisitor::transform(Stmt *stmt) { function Expr (line 944) | Expr *TypecheckVisitor::castToSuperClass(Expr *expr, ClassType *superTyp, function Expr (line 1297) | Expr *TypecheckVisitor::getParamType(Type *t) { function Expr (line 1315) | Expr *TypecheckVisitor::getHeadExpr(Expr *e) { class SearchVisitor (line 1607) | class SearchVisitor : public CallbackASTVisitor { method SearchVisitor (line 1615) | SearchVisitor(const std::function &exprPredicate, method transform (line 1618) | void transform(Expr *expr) override { method transform (line 1628) | void transform(Stmt *stmt) override { function ParserErrors (line 1637) | ParserErrors TypecheckVisitor::findTypecheckErrors(Stmt *n) const { FILE: codon/parser/visitors/typecheck/typecheck.h function namespace (line 17) | namespace codon::ast { FILE: codon/parser/visitors/visitor.cpp type codon::ast (line 7) | namespace codon::ast { FILE: codon/parser/visitors/visitor.h type ASTVisitor (line 17) | struct ASTVisitor { FILE: codon/runtime/exc.cpp type unw_dynamic_unwind_sections (line 38) | struct unw_dynamic_unwind_sections { function find_dynamic_unwind_sections (line 46) | int find_dynamic_unwind_sections(uintptr_t addr, unw_dynamic_unwind_sect... type unw_dynamic_unwind_sections (line 57) | struct unw_dynamic_unwind_sections type BacktraceFrame (line 60) | struct BacktraceFrame { type Backtrace (line 67) | struct Backtrace { type BacktraceFrame (line 69) | struct BacktraceFrame method push_back (line 72) | void push_back(const char *function, const char *filename, uintptr_t pc, method push_back (line 91) | void push_back(uintptr_t pc) { push_back("", "", pc,... method free (line 93) | void free() { function seq_backtrace_error_callback (line 105) | void seq_backtrace_error_callback(void *data, const char *msg, int errnu... function seq_backtrace_full_callback (line 109) | int seq_backtrace_full_callback(void *data, uintptr_t pc, const char *fi... function seq_backtrace_simple_callback (line 116) | int seq_backtrace_simple_callback(void *data, uintptr_t pc) { function ReadType (line 128) | static uintptr_t ReadType(const uint8_t *&p) { type TypeInfo (line 137) | struct TypeInfo { type RTTIObject (line 145) | struct RTTIObject { type CodonBaseExceptionType (line 150) | struct CodonBaseExceptionType { type CodonBaseException (line 154) | struct CodonBaseException { type CodonExceptionHeader (line 160) | struct CodonExceptionHeader { function seq_exc_init (line 170) | void seq_exc_init(int flags) { function seq_delete_exc (line 182) | static void seq_delete_exc(_Unwind_Exception *expToDelete) { function seq_delete_unwind_exc (line 192) | static void seq_delete_unwind_exc(_Unwind_Reason_Code reason, type backtrace_state (line 197) | struct backtrace_state function SEQ_FUNC (line 200) | SEQ_FUNC void *seq_alloc_exc(void *obj) { function print_from_last_dot (line 230) | static void print_from_last_dot(seq_str_t s, std::ostringstream &buf) { function SEQ_FUNC (line 247) | SEQ_FUNC void seq_terminate(void *exc) { function SEQ_FUNC (line 322) | SEQ_FUNC void seq_throw(void *exc) { function readULEB128 (line 328) | static uintptr_t readULEB128(const uint8_t **data) { function readSLEB128 (line 345) | static uintptr_t readSLEB128(const uint8_t **data) { function getEncodingSize (line 366) | static unsigned getEncodingSize(uint8_t encoding) { function readEncodedPointer (line 391) | static uintptr_t readEncodedPointer(const uint8_t **data, uint8_t encodi... function isinstance (line 460) | static bool isinstance(void *obj, seq_int_t type) { function handleActionValue (line 475) | static bool handleActionValue(int64_t *resultAction, uint8_t TTypeEncoding, function _Unwind_Reason_Code (line 524) | static _Unwind_Reason_Code handleLsda(int version, const uint8_t *lsda, function SEQ_FUNC (line 641) | SEQ_FUNC _Unwind_Reason_Code seq_personality(int version, _Unwind_Action... function SEQ_FUNC (line 650) | SEQ_FUNC int64_t seq_exc_offset() { FILE: codon/runtime/floatlib/extenddftf2.c function COMPILER_RT_ABI (line 17) | COMPILER_RT_ABI fp_t __extenddftf2(double a) { FILE: codon/runtime/floatlib/extendhfsf2.c function __extendhfsf2 (line 15) | float __extendhfsf2(src_t a) { function COMPILER_RT_ABI (line 19) | COMPILER_RT_ABI float __gnu_h2f_ieee(src_t a) { return __extendhfsf2(a); } function AEABI_RTABI (line 23) | AEABI_RTABI float __aeabi_h2f(src_t a) { return __extendhfsf2(a); } FILE: codon/runtime/floatlib/extendhftf2.c function __extendhftf2 (line 18) | COMPILER_RT_ABI long double __extendhftf2(_Float16 a) { FILE: codon/runtime/floatlib/extendsfdf2.c function COMPILER_RT_ABI (line 13) | COMPILER_RT_ABI double __extendsfdf2(float a) { return __extendXfYf2__(a... function AEABI_RTABI (line 17) | AEABI_RTABI double __aeabi_f2d(float a) { return __extendsfdf2(a); } FILE: codon/runtime/floatlib/extendsftf2.c function COMPILER_RT_ABI (line 17) | COMPILER_RT_ABI fp_t __extendsftf2(float a) { FILE: codon/runtime/floatlib/fp_extend.h type src_t (line 20) | typedef float src_t; type src_rep_t (line 21) | typedef uint32_t src_rep_t; type src_t (line 27) | typedef double src_t; type src_rep_t (line 28) | typedef uint64_t src_rep_t; function src_rep_t_clz (line 31) | static __inline int src_rep_t_clz(src_rep_t a) { type _Float16 (line 44) | typedef _Float16 src_t; type src_t (line 46) | typedef uint16_t src_t; type src_rep_t (line 48) | typedef uint16_t src_rep_t; type dst_t (line 58) | typedef float dst_t; type dst_rep_t (line 59) | typedef uint32_t dst_rep_t; type dst_t (line 64) | typedef double dst_t; type dst_rep_t (line 65) | typedef uint64_t dst_rep_t; type dst_t (line 70) | typedef long double dst_t; type __uint128_t (line 71) | typedef __uint128_t dst_rep_t; function src_rep_t (line 82) | static __inline src_rep_t srcToRep(src_t x) { function dst_t (line 90) | static __inline dst_t dstFromRep(dst_rep_t x) { FILE: codon/runtime/floatlib/fp_lib.h type half_rep_t (line 32) | typedef uint16_t half_rep_t; type rep_t (line 33) | typedef uint32_t rep_t; type twice_rep_t (line 34) | typedef uint64_t twice_rep_t; type srep_t (line 35) | typedef int32_t srep_t; type fp_t (line 36) | typedef float fp_t; function rep_clz (line 41) | static __inline int rep_clz(rep_t a) { return clzsi(a); } function wideMultiply (line 44) | static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) { type half_rep_t (line 53) | typedef uint32_t half_rep_t; type rep_t (line 54) | typedef uint64_t rep_t; type srep_t (line 55) | typedef int64_t srep_t; type fp_t (line 56) | typedef double fp_t; function rep_clz (line 61) | static __inline int rep_clz(rep_t a) { function wideMultiply (line 78) | static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) { type half_rep_t (line 98) | typedef uint64_t half_rep_t; type __uint128_t (line 99) | typedef __uint128_t rep_t; type __int128_t (line 100) | typedef __int128_t srep_t; type tf_float (line 101) | typedef tf_float fp_t; function rep_clz (line 110) | static __inline int rep_clz(rep_t a) { function wideMultiply (line 148) | static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) { type fp_t (line 195) | typedef long double fp_t; function rep_t (line 205) | static __inline rep_t toRep(fp_t x) { function fp_t (line 213) | static __inline fp_t fromRep(rep_t x) { function normalize (line 236) | static __inline int normalize(rep_t *significand) { function wideLeftShift (line 242) | static __inline void wideLeftShift(rep_t *hi, rep_t *lo, int count) { function wideRightShiftWithSticky (line 247) | static __inline void wideRightShiftWithSticky(rep_t *hi, rep_t *lo, function fp_t (line 268) | static __inline fp_t __compiler_rt_logbX(fp_t x) { function fp_t (line 300) | static __inline fp_t __compiler_rt_scalbnX(fp_t x, int y) { function fp_t (line 341) | static __inline fp_t __compiler_rt_fmaxX(fp_t x, fp_t y) { function fp_t (line 352) | static __inline fp_t __compiler_rt_logbf(fp_t x) { return __compiler_rt_... function fp_t (line 353) | static __inline fp_t __compiler_rt_scalbnf(fp_t x, int y) { function fp_t (line 356) | static __inline fp_t __compiler_rt_fmaxf(fp_t x, fp_t y) { function fp_t (line 368) | static __inline fp_t __compiler_rt_logb(fp_t x) { return __compiler_rt_l... function fp_t (line 369) | static __inline fp_t __compiler_rt_scalbn(fp_t x, int y) { function fp_t (line 372) | static __inline fp_t __compiler_rt_fmax(fp_t x, fp_t y) { function tf_float (line 386) | static __inline tf_float __compiler_rt_logbtf(tf_float x) { function tf_float (line 389) | static __inline tf_float __compiler_rt_scalbntf(tf_float x, int y) { function tf_float (line 392) | static __inline tf_float __compiler_rt_fmaxtf(tf_float x, tf_float y) { function tf_float (line 401) | static __inline tf_float __compiler_rt_logbtf(tf_float x) { return crt_l... function tf_float (line 402) | static __inline tf_float __compiler_rt_scalbntf(tf_float x, int y) { function tf_float (line 405) | static __inline tf_float __compiler_rt_fmaxtf(tf_float x, tf_float y) { FILE: codon/runtime/floatlib/fp_trunc.h type src_t (line 19) | typedef float src_t; type src_rep_t (line 20) | typedef uint32_t src_rep_t; type src_t (line 25) | typedef double src_t; type src_rep_t (line 26) | typedef uint64_t src_rep_t; type src_t (line 31) | typedef long double src_t; type __uint128_t (line 32) | typedef __uint128_t src_rep_t; type dst_t (line 41) | typedef double dst_t; type dst_rep_t (line 42) | typedef uint64_t dst_rep_t; type dst_t (line 47) | typedef float dst_t; type dst_rep_t (line 48) | typedef uint32_t dst_rep_t; type _Float16 (line 54) | typedef _Float16 dst_t; type dst_t (line 56) | typedef uint16_t dst_t; type dst_rep_t (line 58) | typedef uint16_t dst_rep_t; type __bf16 (line 63) | typedef __bf16 dst_t; type dst_rep_t (line 64) | typedef uint16_t dst_rep_t; function src_rep_t (line 75) | static __inline src_rep_t srcToRep(src_t x) { function dst_t (line 83) | static __inline dst_t dstFromRep(dst_rep_t x) { FILE: codon/runtime/floatlib/int_lib.h function __builtin_ctz (line 121) | int __inline __builtin_ctz(uint32_t value) { function __builtin_clz (line 128) | int __inline __builtin_clz(uint32_t value) { function __builtin_clzll (line 136) | int __inline __builtin_clzll(uint64_t value) { function __builtin_clzll (line 143) | int __inline __builtin_clzll(uint64_t value) { function __builtin_sadd_overflow (line 156) | bool __inline __builtin_sadd_overflow(int x, int y, int *result) { FILE: codon/runtime/floatlib/int_types.h type si_int (line 25) | typedef int32_t si_int; type su_int (line 26) | typedef uint32_t su_int; type di_int (line 37) | typedef int64_t di_int; type du_int (line 38) | typedef uint64_t du_int; type dwords (line 40) | typedef union { type udwords (line 53) | typedef union { type ti_int (line 79) | typedef int ti_int __attribute__((mode(TI))); type tu_int (line 80) | typedef unsigned tu_int __attribute__((mode(TI))); type twords (line 82) | typedef union { type utwords (line 95) | typedef union { function ti_int (line 108) | static __inline ti_int make_ti(di_int h, di_int l) { function tu_int (line 115) | static __inline tu_int make_tu(du_int h, du_int l) { type float_bits (line 133) | typedef union { type double_bits (line 138) | typedef union { type uqwords (line 144) | typedef struct { type long_double_bits (line 169) | typedef union { type _Complex (line 175) | typedef float _Complex Fcomplex; type _Complex (line 176) | typedef double _Complex Dcomplex; type _Complex (line 177) | typedef long double _Complex Lcomplex; type Fcomplex (line 182) | typedef struct { type Dcomplex (line 186) | typedef struct { type Lcomplex (line 190) | typedef struct { FILE: codon/runtime/floatlib/truncdfbf2.c function COMPILER_RT_ABI (line 13) | COMPILER_RT_ABI dst_t __truncdfbf2(double a) { return __truncXfYf2__(a); } FILE: codon/runtime/floatlib/truncdfhf2.c function COMPILER_RT_ABI (line 13) | COMPILER_RT_ABI dst_t __truncdfhf2(double a) { return __truncXfYf2__(a); } function AEABI_RTABI (line 17) | AEABI_RTABI dst_t __aeabi_d2h(double a) { return __truncdfhf2(a); } FILE: codon/runtime/floatlib/truncdfsf2.c function COMPILER_RT_ABI (line 13) | COMPILER_RT_ABI float __truncdfsf2(double a) { return __truncXfYf2__(a); } function AEABI_RTABI (line 17) | AEABI_RTABI float __aeabi_d2f(double a) { return __truncdfsf2(a); } FILE: codon/runtime/floatlib/truncsfbf2.c function COMPILER_RT_ABI (line 13) | COMPILER_RT_ABI dst_t __truncsfbf2(float a) { return __truncXfYf2__(a); } FILE: codon/runtime/floatlib/truncsfhf2.c function dst_t (line 15) | dst_t __truncsfhf2(float a) { function COMPILER_RT_ABI (line 19) | COMPILER_RT_ABI dst_t __gnu_f2h_ieee(float a) { return __truncsfhf2(a); } function AEABI_RTABI (line 23) | AEABI_RTABI dst_t __aeabi_f2h(float a) { return __truncsfhf2(a); } FILE: codon/runtime/floatlib/trunctfdf2.c function COMPILER_RT_ABI (line 17) | COMPILER_RT_ABI double __trunctfdf2(long double a) { return __truncXfYf2... FILE: codon/runtime/floatlib/trunctfhf2.c function COMPILER_RT_ABI (line 18) | COMPILER_RT_ABI _Float16 __trunctfhf2(long double a) { FILE: codon/runtime/floatlib/trunctfsf2.c function COMPILER_RT_ABI (line 17) | COMPILER_RT_ABI float __trunctfsf2(long double a) { return __truncXfYf2_... FILE: codon/runtime/lib.cpp function SEQ_FUNC (line 51) | SEQ_FUNC void seq_init(int flags) { function SEQ_FUNC (line 64) | SEQ_FUNC seq_int_t seq_pid() { return (seq_int_t)getpid(); } function SEQ_FUNC (line 66) | SEQ_FUNC seq_int_t seq_time() { function SEQ_FUNC (line 73) | SEQ_FUNC seq_int_t seq_time_monotonic() { function SEQ_FUNC (line 80) | SEQ_FUNC seq_int_t seq_time_highres() { function copy_time_c_to_seq (line 87) | static void copy_time_c_to_seq(struct tm *x, seq_time_t *output) { function copy_time_seq_to_c (line 99) | static void copy_time_seq_to_c(seq_time_t *x, struct tm *output) { function SEQ_FUNC (line 111) | SEQ_FUNC bool seq_localtime(seq_int_t secs, seq_time_t *output) { function SEQ_FUNC (line 120) | SEQ_FUNC bool seq_gmtime(seq_int_t secs, seq_time_t *output) { function SEQ_FUNC (line 129) | SEQ_FUNC seq_int_t seq_mktime(seq_time_t *time) { function SEQ_FUNC (line 135) | SEQ_FUNC void seq_sleep(double secs) { function SEQ_FUNC (line 140) | SEQ_FUNC char **seq_env() { return environ; } function SEQ_FUNC (line 146) | SEQ_FUNC void *seq_alloc(size_t n) { function SEQ_FUNC (line 154) | SEQ_FUNC void *seq_alloc_atomic(size_t n) { function SEQ_FUNC (line 162) | SEQ_FUNC void *seq_alloc_uncollectable(size_t n) { function SEQ_FUNC (line 170) | SEQ_FUNC void *seq_alloc_atomic_uncollectable(size_t n) { function SEQ_FUNC (line 178) | SEQ_FUNC void *seq_realloc(void *p, size_t newsize, size_t oldsize) { function SEQ_FUNC (line 186) | SEQ_FUNC void seq_free(void *p) { function SEQ_FUNC (line 194) | SEQ_FUNC void seq_register_finalizer(void *p, void (*f)(void *obj, void ... function SEQ_FUNC (line 200) | SEQ_FUNC void seq_gc_add_roots(void *start, void *end) { function SEQ_FUNC (line 206) | SEQ_FUNC void seq_gc_remove_roots(void *start, void *end) { function SEQ_FUNC (line 212) | SEQ_FUNC void seq_gc_clear_roots() { function SEQ_FUNC (line 218) | SEQ_FUNC void seq_gc_exclude_static_roots(void *start, void *end) { function seq_str_t (line 227) | static seq_str_t string_conv(const std::string &s) { function default_format (line 234) | std::string default_format(T n) { function default_format (line 238) | std::string default_format(double n) { function seq_str_t (line 242) | seq_str_t fmt_conv(T n, seq_str_t format, bool *error) { function SEQ_FUNC (line 259) | SEQ_FUNC seq_str_t seq_str_int(seq_int_t n, seq_str_t format, bool *erro... function SEQ_FUNC (line 263) | SEQ_FUNC seq_str_t seq_str_uint(seq_int_t n, seq_str_t format, bool *err... function SEQ_FUNC (line 267) | SEQ_FUNC seq_str_t seq_str_float(double f, seq_str_t format, bool *error) { function SEQ_FUNC (line 271) | SEQ_FUNC seq_str_t seq_str_ptr(void *p, seq_str_t format, bool *error) { function SEQ_FUNC (line 275) | SEQ_FUNC seq_str_t seq_str_str(seq_str_t s, seq_str_t format, bool *erro... function SEQ_FUNC (line 280) | SEQ_FUNC seq_int_t seq_int_from_str(seq_str_t s, const char **e, int bas... function SEQ_FUNC (line 287) | SEQ_FUNC double seq_float_from_str(seq_str_t s, const char **e) { function SEQ_FUNC (line 298) | SEQ_FUNC seq_str_t seq_check_errno() { function SEQ_FUNC (line 308) | SEQ_FUNC void seq_print(seq_str_t str) { seq_print_full(str, stdout); } function SEQ_FUNC (line 313) | SEQ_FUNC void seq_print_full(seq_str_t str, FILE *fo) { function SEQ_FUNC (line 329) | SEQ_FUNC void *seq_stdin() { return stdin; } function SEQ_FUNC (line 331) | SEQ_FUNC void *seq_stdout() { return stdout; } function SEQ_FUNC (line 333) | SEQ_FUNC void *seq_stderr() { return stderr; } function SEQ_FUNC (line 339) | SEQ_FUNC void *seq_lock_new() { function SEQ_FUNC (line 343) | SEQ_FUNC bool seq_lock_acquire(void *lock, bool block, double timeout) { function SEQ_FUNC (line 357) | SEQ_FUNC void seq_lock_release(void *lock) { function SEQ_FUNC (line 362) | SEQ_FUNC void *seq_rlock_new() { function SEQ_FUNC (line 367) | SEQ_FUNC bool seq_rlock_acquire(void *lock, bool block, double timeout) { function SEQ_FUNC (line 381) | SEQ_FUNC void seq_rlock_release(void *lock) { FILE: codon/runtime/lib.h type seq_int_t (line 24) | typedef int64_t seq_int_t; type seq_str_t (line 26) | struct seq_str_t { type seq_time_t (line 31) | struct seq_time_t { function namespace (line 99) | namespace codon { FILE: codon/runtime/numpy/loops.cpp type HWY_NAMESPACE (line 24) | namespace HWY_NAMESPACE { type AcosFunctor (line 28) | struct AcosFunctor { method vector (line 30) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 34) | static inline double scalar(const double x) { return acos(x); } method scalar (line 36) | static inline float scalar(const float x) { return acosf(x); } type AcoshFunctor (line 39) | struct AcoshFunctor { method vector (line 41) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 48) | static inline double scalar(const double x) { return acosh(x); } method scalar (line 50) | static inline float scalar(const float x) { return acoshf(x); } type AsinFunctor (line 53) | struct AsinFunctor { method vector (line 55) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 59) | static inline double scalar(const double x) { return asin(x); } method scalar (line 61) | static inline float scalar(const float x) { return asinf(x); } type AsinhFunctor (line 64) | struct AsinhFunctor { method vector (line 66) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 73) | static inline double scalar(const double x) { return asinh(x); } method scalar (line 75) | static inline float scalar(const float x) { return asinhf(x); } type AtanFunctor (line 78) | struct AtanFunctor { method vector (line 80) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 88) | static inline double scalar(const double x) { return atan(x); } method scalar (line 90) | static inline float scalar(const float x) { return atanf(x); } type AtanhFunctor (line 93) | struct AtanhFunctor { method vector (line 95) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 107) | static inline double scalar(const double x) { return atanh(x); } method scalar (line 109) | static inline float scalar(const float x) { return atanhf(x); } type Atan2Functor (line 112) | struct Atan2Functor { method vector (line 114) | static inline auto vector(const hn::ScalableTag d, const V &v1, c... method scalar (line 135) | static inline auto scalar(const double x, const double y) { return a... method scalar (line 137) | static inline auto scalar(const float x, const float y) { return ata... type CosFunctor (line 140) | struct CosFunctor { method T (line 141) | static inline T limit() { method vector (line 152) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 172) | static inline double scalar(const double x) { return cos(x); } method scalar (line 174) | static inline float scalar(const float x) { return cosf(x); } type ExpFunctor (line 177) | struct ExpFunctor { method T (line 178) | static inline T limit() { method vector (line 189) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 195) | static inline double scalar(const double x) { return exp(x); } method scalar (line 197) | static inline float scalar(const float x) { return expf(x); } type Exp2Functor (line 200) | struct Exp2Functor { method T (line 201) | static inline T limit() { method vector (line 212) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 218) | static inline double scalar(const double x) { return exp2(x); } method scalar (line 220) | static inline float scalar(const float x) { return exp2f(x); } type Expm1Functor (line 223) | struct Expm1Functor { method T (line 224) | static inline T limit() { method vector (line 235) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 241) | static inline double scalar(const double x) { return expm1(x); } method scalar (line 243) | static inline float scalar(const float x) { return expm1f(x); } type LogFunctor (line 246) | struct LogFunctor { method vector (line 248) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 259) | static inline double scalar(const double x) { return log(x); } method scalar (line 261) | static inline float scalar(const float x) { return logf(x); } type Log10Functor (line 264) | struct Log10Functor { method vector (line 266) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 277) | static inline double scalar(const double x) { return log10(x); } method scalar (line 279) | static inline float scalar(const float x) { return log10f(x); } type Log1pFunctor (line 282) | struct Log1pFunctor { method vector (line 284) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 295) | static inline double scalar(const double x) { return log1p(x); } method scalar (line 297) | static inline float scalar(const float x) { return log1pf(x); } type Log2Functor (line 300) | struct Log2Functor { method vector (line 302) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 313) | static inline double scalar(const double x) { return log2(x); } method scalar (line 315) | static inline float scalar(const float x) { return log2f(x); } type SinFunctor (line 318) | struct SinFunctor { method T (line 319) | static inline T limit() { method vector (line 330) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 350) | static inline double scalar(const double x) { return sin(x); } method scalar (line 352) | static inline float scalar(const float x) { return sinf(x); } type SinhFunctor (line 355) | struct SinhFunctor { method T (line 356) | static inline T limit() { method vector (line 367) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 387) | static inline double scalar(const double x) { return sinh(x); } method scalar (line 389) | static inline float scalar(const float x) { return sinhf(x); } type TanhFunctor (line 392) | struct TanhFunctor { method vector (line 394) | static inline auto vector(const hn::ScalableTag d, const V &v) { method scalar (line 398) | static inline double scalar(const double x) { return tanh(x); } method scalar (line 400) | static inline float scalar(const float x) { return tanhf(x); } type HypotFunctor (line 403) | struct HypotFunctor { method vector (line 405) | static inline auto vector(const hn::ScalableTag d, const V &v1, c... method scalar (line 409) | static inline auto scalar(const double x, const double y) { return h... method scalar (line 411) | static inline auto scalar(const float x, const float y) { return hyp... function UnaryLoop (line 415) | void UnaryLoop(const T *in, size_t is, T *out, size_t os, size_t n) { function BinaryLoop (line 449) | void BinaryLoop(const T *in1, size_t is1, const T *in2, size_t is2, T ... function LoopAcos32 (line 518) | void LoopAcos32(const float *in, size_t is, float *out, size_t os, siz... function LoopAcos64 (line 522) | void LoopAcos64(const double *in, size_t is, double *out, size_t os, s... function LoopAcosh32 (line 526) | void LoopAcosh32(const float *in, size_t is, float *out, size_t os, si... function LoopAcosh64 (line 530) | void LoopAcosh64(const double *in, size_t is, double *out, size_t os, ... function LoopAsin32 (line 534) | void LoopAsin32(const float *in, size_t is, float *out, size_t os, siz... function LoopAsin64 (line 538) | void LoopAsin64(const double *in, size_t is, double *out, size_t os, s... function LoopAsinh32 (line 542) | void LoopAsinh32(const float *in, size_t is, float *out, size_t os, si... function LoopAsinh64 (line 546) | void LoopAsinh64(const double *in, size_t is, double *out, size_t os, ... function LoopAtan32 (line 550) | void LoopAtan32(const float *in, size_t is, float *out, size_t os, siz... function LoopAtan64 (line 554) | void LoopAtan64(const double *in, size_t is, double *out, size_t os, s... function LoopAtanh32 (line 558) | void LoopAtanh32(const float *in, size_t is, float *out, size_t os, si... function LoopAtanh64 (line 562) | void LoopAtanh64(const double *in, size_t is, double *out, size_t os, ... function LoopAtan232 (line 566) | void LoopAtan232(const float *in1, size_t is1, const float *in2, size_... function LoopAtan264 (line 571) | void LoopAtan264(const double *in1, size_t is1, const double *in2, siz... function LoopCos32 (line 576) | void LoopCos32(const float *in, size_t is, float *out, size_t os, size... function LoopCos64 (line 580) | void LoopCos64(const double *in, size_t is, double *out, size_t os, si... function LoopExp32 (line 584) | void LoopExp32(const float *in, size_t is, float *out, size_t os, size... function LoopExp64 (line 588) | void LoopExp64(const double *in, size_t is, double *out, size_t os, si... function LoopExp232 (line 592) | void LoopExp232(const float *in, size_t is, float *out, size_t os, siz... function LoopExp264 (line 596) | void LoopExp264(const double *in, size_t is, double *out, size_t os, s... function LoopExpm132 (line 600) | void LoopExpm132(const float *in, size_t is, float *out, size_t os, si... function LoopExpm164 (line 604) | void LoopExpm164(const double *in, size_t is, double *out, size_t os, ... function LoopLog32 (line 608) | void LoopLog32(const float *in, size_t is, float *out, size_t os, size... function LoopLog64 (line 612) | void LoopLog64(const double *in, size_t is, double *out, size_t os, si... function LoopLog1032 (line 616) | void LoopLog1032(const float *in, size_t is, float *out, size_t os, si... function LoopLog1064 (line 620) | void LoopLog1064(const double *in, size_t is, double *out, size_t os, ... function LoopLog1p32 (line 624) | void LoopLog1p32(const float *in, size_t is, float *out, size_t os, si... function LoopLog1p64 (line 628) | void LoopLog1p64(const double *in, size_t is, double *out, size_t os, ... function LoopLog232 (line 632) | void LoopLog232(const float *in, size_t is, float *out, size_t os, siz... function LoopLog264 (line 636) | void LoopLog264(const double *in, size_t is, double *out, size_t os, s... function LoopSin32 (line 640) | void LoopSin32(const float *in, size_t is, float *out, size_t os, size... function LoopSin64 (line 644) | void LoopSin64(const double *in, size_t is, double *out, size_t os, si... function LoopSinh32 (line 648) | void LoopSinh32(const float *in, size_t is, float *out, size_t os, siz... function LoopSinh64 (line 652) | void LoopSinh64(const double *in, size_t is, double *out, size_t os, s... function LoopTanh32 (line 656) | void LoopTanh32(const float *in, size_t is, float *out, size_t os, siz... function LoopTanh64 (line 660) | void LoopTanh64(const double *in, size_t is, double *out, size_t os, s... function LoopHypot32 (line 664) | void LoopHypot32(const float *in1, size_t is1, const float *in2, size_... function LoopHypot64 (line 669) | void LoopHypot64(const double *in1, size_t is1, const double *in2, siz... function SEQ_FUNC (line 719) | SEQ_FUNC void cnp_acos_float32(const float *in, size_t is, float *out, s... function SEQ_FUNC (line 725) | SEQ_FUNC void cnp_acos_float64(const double *in, size_t is, double *out,... function SEQ_FUNC (line 731) | SEQ_FUNC void cnp_acosh_float32(const float *in, size_t is, float *out, ... function SEQ_FUNC (line 737) | SEQ_FUNC void cnp_acosh_float64(const double *in, size_t is, double *out... function SEQ_FUNC (line 743) | SEQ_FUNC void cnp_asin_float32(const float *in, size_t is, float *out, s... function SEQ_FUNC (line 749) | SEQ_FUNC void cnp_asin_float64(const double *in, size_t is, double *out,... function SEQ_FUNC (line 755) | SEQ_FUNC void cnp_asinh_float32(const float *in, size_t is, float *out, ... function SEQ_FUNC (line 761) | SEQ_FUNC void cnp_asinh_float64(const double *in, size_t is, double *out... function SEQ_FUNC (line 767) | SEQ_FUNC void cnp_atan_float32(const float *in, size_t is, float *out, s... function SEQ_FUNC (line 773) | SEQ_FUNC void cnp_atan_float64(const double *in, size_t is, double *out,... function SEQ_FUNC (line 779) | SEQ_FUNC void cnp_atanh_float32(const float *in, size_t is, float *out, ... function SEQ_FUNC (line 785) | SEQ_FUNC void cnp_atanh_float64(const double *in, size_t is, double *out... function SEQ_FUNC (line 791) | SEQ_FUNC void cnp_atan2_float32(const float *in1, size_t is1, const floa... function SEQ_FUNC (line 797) | SEQ_FUNC void cnp_atan2_float64(const double *in1, size_t is1, const dou... function SEQ_FUNC (line 803) | SEQ_FUNC void cnp_cos_float32(const float *in, size_t is, float *out, si... function SEQ_FUNC (line 809) | SEQ_FUNC void cnp_cos_float64(const double *in, size_t is, double *out, ... function SEQ_FUNC (line 815) | SEQ_FUNC void cnp_exp_float32(const float *in, size_t is, float *out, si... function SEQ_FUNC (line 821) | SEQ_FUNC void cnp_exp_float64(const double *in, size_t is, double *out, ... function SEQ_FUNC (line 827) | SEQ_FUNC void cnp_exp2_float32(const float *in, size_t is, float *out, s... function SEQ_FUNC (line 833) | SEQ_FUNC void cnp_exp2_float64(const double *in, size_t is, double *out,... function SEQ_FUNC (line 839) | SEQ_FUNC void cnp_expm1_float32(const float *in, size_t is, float *out, ... function SEQ_FUNC (line 845) | SEQ_FUNC void cnp_expm1_float64(const double *in, size_t is, double *out... function SEQ_FUNC (line 851) | SEQ_FUNC void cnp_log_float32(const float *in, size_t is, float *out, si... function SEQ_FUNC (line 857) | SEQ_FUNC void cnp_log_float64(const double *in, size_t is, double *out, ... function SEQ_FUNC (line 863) | SEQ_FUNC void cnp_log10_float32(const float *in, size_t is, float *out, ... function SEQ_FUNC (line 869) | SEQ_FUNC void cnp_log10_float64(const double *in, size_t is, double *out... function SEQ_FUNC (line 875) | SEQ_FUNC void cnp_log1p_float32(const float *in, size_t is, float *out, ... function SEQ_FUNC (line 881) | SEQ_FUNC void cnp_log1p_float64(const double *in, size_t is, double *out... function SEQ_FUNC (line 887) | SEQ_FUNC void cnp_log2_float32(const float *in, size_t is, float *out, s... function SEQ_FUNC (line 893) | SEQ_FUNC void cnp_log2_float64(const double *in, size_t is, double *out,... function SEQ_FUNC (line 899) | SEQ_FUNC void cnp_sin_float32(const float *in, size_t is, float *out, si... function SEQ_FUNC (line 905) | SEQ_FUNC void cnp_sin_float64(const double *in, size_t is, double *out, ... function SEQ_FUNC (line 911) | SEQ_FUNC void cnp_sinh_float32(const float *in, size_t is, float *out, s... function SEQ_FUNC (line 917) | SEQ_FUNC void cnp_sinh_float64(const double *in, size_t is, double *out,... function SEQ_FUNC (line 923) | SEQ_FUNC void cnp_tanh_float32(const float *in, size_t is, float *out, s... function SEQ_FUNC (line 929) | SEQ_FUNC void cnp_tanh_float64(const double *in, size_t is, double *out,... function SEQ_FUNC (line 935) | SEQ_FUNC void cnp_hypot_float32(const float *in1, size_t is1, const floa... function SEQ_FUNC (line 941) | SEQ_FUNC void cnp_hypot_float64(const double *in1, size_t is1, const dou... FILE: codon/runtime/numpy/sort.cpp function SEQ_FUNC (line 6) | SEQ_FUNC void cnp_sort_int16(int16_t *data, int64_t n) { function SEQ_FUNC (line 10) | SEQ_FUNC void cnp_sort_uint16(uint16_t *data, int64_t n) { function SEQ_FUNC (line 14) | SEQ_FUNC void cnp_sort_int32(int32_t *data, int64_t n) { function SEQ_FUNC (line 18) | SEQ_FUNC void cnp_sort_uint32(uint32_t *data, int64_t n) { function SEQ_FUNC (line 22) | SEQ_FUNC void cnp_sort_int64(int64_t *data, int64_t n) { function SEQ_FUNC (line 26) | SEQ_FUNC void cnp_sort_uint64(uint64_t *data, int64_t n) { function SEQ_FUNC (line 30) | SEQ_FUNC void cnp_sort_uint128(hwy::uint128_t *data, int64_t n) { function SEQ_FUNC (line 34) | SEQ_FUNC void cnp_sort_float32(float *data, int64_t n) { function SEQ_FUNC (line 38) | SEQ_FUNC void cnp_sort_float64(double *data, int64_t n) { FILE: codon/runtime/numpy/zmath.cpp function SEQ_FUNC (line 10) | SEQ_FUNC void cnp_cexpf(float r, float i, float *z) { function SEQ_FUNC (line 17) | SEQ_FUNC void cnp_clogf(float r, float i, float *z) { function SEQ_FUNC (line 24) | SEQ_FUNC void cnp_csqrtf(float r, float i, float *z) { function SEQ_FUNC (line 31) | SEQ_FUNC void cnp_ccoshf(float r, float i, float *z) { function SEQ_FUNC (line 38) | SEQ_FUNC void cnp_csinhf(float r, float i, float *z) { function SEQ_FUNC (line 45) | SEQ_FUNC void cnp_ctanhf(float r, float i, float *z) { function SEQ_FUNC (line 52) | SEQ_FUNC void cnp_cacoshf(float r, float i, float *z) { function SEQ_FUNC (line 59) | SEQ_FUNC void cnp_casinhf(float r, float i, float *z) { function SEQ_FUNC (line 66) | SEQ_FUNC void cnp_catanhf(float r, float i, float *z) { function SEQ_FUNC (line 73) | SEQ_FUNC void cnp_ccosf(float r, float i, float *z) { function SEQ_FUNC (line 80) | SEQ_FUNC void cnp_csinf(float r, float i, float *z) { function SEQ_FUNC (line 87) | SEQ_FUNC void cnp_ctanf(float r, float i, float *z) { function SEQ_FUNC (line 94) | SEQ_FUNC void cnp_cacosf(float r, float i, float *z) { function SEQ_FUNC (line 101) | SEQ_FUNC void cnp_casinf(float r, float i, float *z) { function SEQ_FUNC (line 108) | SEQ_FUNC void cnp_catanf(float r, float i, float *z) { FILE: codon/runtime/re.cpp function flags2opt (line 27) | static inline Regex::Options flags2opt(seq_int_t flags) { type Span (line 67) | struct Span { type GCMapAllocator (line 72) | struct GCMapAllocator : public std::allocator { method GCMapAllocator (line 73) | GCMapAllocator() = default; method GCMapAllocator (line 74) | GCMapAllocator(GCMapAllocator const &) = default; method GCMapAllocator (line 76) | GCMapAllocator(const GCMapAllocator &) noexcept {} method KV (line 78) | KV *allocate(std::size_t n) { return (KV *)seq_alloc_uncollectable(n *... method deallocate (line 80) | void deallocate(KV *p, std::size_t n) { seq_free(p); } type rebind (line 82) | struct rebind { function seq_str_t (line 87) | static inline seq_str_t convert(const std::string &p) { function StringPiece (line 94) | static inline StringPiece str2sp(const seq_str_t &s) { type KeyEqual (line 100) | struct KeyEqual { type KeyHash (line 106) | struct KeyHash { function Regex (line 117) | static inline Regex *get(const seq_str_t &p, seq_int_t flags) { function SEQ_FUNC (line 133) | SEQ_FUNC Span *seq_re_match(Regex *re, seq_int_t anchor, seq_str_t s, se... function SEQ_FUNC (line 161) | SEQ_FUNC Span seq_re_match_one(Regex *re, seq_int_t anchor, seq_str_t s,... function SEQ_FUNC (line 175) | SEQ_FUNC seq_str_t seq_re_escape(seq_str_t p) { function SEQ_FUNC (line 179) | SEQ_FUNC Regex *seq_re_compile(seq_str_t p, seq_int_t flags) { return ge... function SEQ_FUNC (line 181) | SEQ_FUNC void seq_re_purge() { cache.clear(); } function SEQ_FUNC (line 187) | SEQ_FUNC seq_int_t seq_re_pattern_groups(Regex *pattern) { function SEQ_FUNC (line 191) | SEQ_FUNC seq_int_t seq_re_group_name_to_index(Regex *pattern, seq_str_t ... function SEQ_FUNC (line 197) | SEQ_FUNC seq_str_t seq_re_group_index_to_name(Regex *pattern, seq_int_t ... function SEQ_FUNC (line 204) | SEQ_FUNC bool seq_re_check_rewrite_string(Regex *pattern, seq_str_t rewr... function SEQ_FUNC (line 213) | SEQ_FUNC seq_str_t seq_re_pattern_error(Regex *pattern) { FILE: codon/util/common.cpp type codon (line 11) | namespace codon { function compilationMessage (line 13) | void compilationMessage(const std::string &header, const std::string &... function compilationError (line 66) | void compilationError(const std::string &msg, const std::string &file,... function compilationWarning (line 75) | void compilationWarning(const std::string &msg, const std::string &fil... FILE: codon/util/common.h function namespace (line 69) | namespace codon { function elapsed (line 113) | double elapsed(std::chrono::time_point end = clock_type::now... type SrcObject (line 127) | struct SrcObject { function SrcObject (line 139) | SrcObject *setSrcInfo(SrcInfo info) { type MessageGroupPos (line 156) | enum MessageGroupPos { function ostream_formatter (line 173) | struct fmt::formatter : fmt::ostream_formatter {} FILE: codon/util/jupyter.cpp type codon (line 6) | namespace codon { function startJupyterKernel (line 7) | int startJupyterKernel(const std::string &argv0, FILE: codon/util/jupyter.h function namespace (line 8) | namespace codon { FILE: codon/util/peg2cpp.cpp function string (line 30) | string escape(const string &str) { function string (line 59) | string join(const T &items, const string &delim = " ", int start = 0, in... class PrintVisitor (line 74) | class PrintVisitor : public peg::Ope::Visitor { method string (line 78) | static string parse(const shared_ptr &op) { method visit (line 91) | void visit(peg::Sequence &s) override { method visit (line 96) | void visit(peg::PrioritizedChoice &s) override { method visit (line 101) | void visit(peg::Repetition &s) override { method visit (line 111) | void visit(peg::AndPredicate &s) override { v = {"apd", parse(s.ope_)}; } method visit (line 112) | void visit(peg::NotPredicate &s) override { v = {"npd", parse(s.ope_)}; } method visit (line 113) | void visit(peg::LiteralString &s) override { method visit (line 116) | void visit(peg::CharacterClass &s) override { method visit (line 122) | void visit(peg::Character &s) override { v = {"chr", fmt::format("'{}'... method visit (line 123) | void visit(peg::AnyCharacter &s) override { v = {"dot"}; } method visit (line 124) | void visit(peg::Cut &s) override { v = {"cut"}; } method visit (line 125) | void visit(peg::Reference &s) override { method visit (line 136) | void visit(peg::TokenBoundary &s) override { v = {"tok", parse(s.ope_)... method visit (line 137) | void visit(peg::Ignore &s) override { v = {"ign", parse(s.ope_)}; } method visit (line 138) | void visit(peg::Recovery &s) override { v = {"rec", parse(s.ope_)}; } function main (line 142) | int main(int argc, char **argv) { FILE: codon/util/serialize.h function namespace (line 11) | namespace codon { FILE: codon/util/tser.h function namespace (line 15) | namespace tser { function namespace (line 41) | namespace tser { function std (line 51) | static std::string encode_base64(std::string_view in) { function explicit (line 221) | explicit BinaryArchive(std::string encodedStr) function else (line 232) | else if constexpr (is_tser_t_v) function else (line 234) | else if constexpr (is_tuple_v) function else (line 236) | else if constexpr (is_pointer_like_v) { FILE: jit/codon/decorator.py function _common_type (line 63) | def _common_type(t, debug, sample_size): function _codon_type (line 77) | def _codon_type(arg, **kwargs): function _codon_types (line 146) | def _codon_types(args, **kwargs): function _reset_jit (line 149) | def _reset_jit(): class RewriteFunctionArgs (line 166) | class RewriteFunctionArgs(ast.NodeTransformer): method __init__ (line 167) | def __init__(self, args): method visit_FunctionDef (line 170) | def visit_FunctionDef(self, node): function _obj_to_str (line 175) | def _obj_to_str(obj, **kwargs) -> str: function _parse_decorated (line 209) | def _parse_decorated(obj, **kwargs): function convert (line 212) | def convert(t): function _jit_register_fn (line 239) | def _jit_register_fn(f, pyvars, debug): function _jit_callback_fn (line 253) | def _jit_callback_fn(fn, function _jit_str_fn (line 280) | def _jit_str_fn(fstr, debug=0, sample_size=5, pyvars=None): function jit (line 290) | def jit(fn=None, debug=0, sample_size=5, pyvars=None): function execute (line 318) | def execute(code, debug=0): FILE: jupyter/jupyter.cpp type codon (line 27) | namespace codon { function startJupyterKernel (line 134) | int startJupyterKernel(const std::string &argv0, FILE: jupyter/jupyter.h function namespace (line 11) | namespace codon { FILE: scripts/docgen.py function remove_root (line 26) | def remove_root(path, roots): function parse_docstr (line 64) | def parse_docstr(s, level=0): function parse_type (line 78) | def parse_type(a): function parse_fn (line 96) | def parse_fn(v): function write_tag (line 151) | def write_tag(tag, f): function write_tags (line 161) | def write_tags(v, f): function write_docstr (line 168) | def write_docstr(v, f): FILE: test/app/test.c function main (line 2) | int main(void) { foo(3); } FILE: test/cir/analyze/dominator.cpp function TEST_F (line 8) | TEST_F(CIRCoreTest, DominatorAnalysisSimple) { function TEST_F (line 30) | TEST_F(CIRCoreTest, DominatorAnalysisTernary) { FILE: test/cir/analyze/reaching.cpp function rdset (line 9) | std::unordered_set rdset(analyze::dataflow::RDInspector... function TEST_F (line 21) | TEST_F(CIRCoreTest, RDAnalysisSimple) { function TEST_F (line 65) | TEST_F(CIRCoreTest, RDAnalysisIfConditional) { function TEST_F (line 104) | TEST_F(CIRCoreTest, RDAnalysisTryCatch) { function TEST_F (line 156) | TEST_F(CIRCoreTest, RDAnalysisWhileLoop) { FILE: test/cir/base.cpp class TestVisitor (line 6) | class TestVisitor : public codon::ir::util::Visitor { method visit (line 8) | void visit(codon::ir::IntConst *) override { FAIL(); } method visit (line 9) | void visit(codon::ir::BoolConst *) override {} class ConstTestVisitor (line 12) | class ConstTestVisitor : public codon::ir::util::ConstVisitor { method visit (line 14) | void visit(const codon::ir::IntConst *) override { FAIL(); } method visit (line 15) | void visit(const codon::ir::BoolConst *) override {} function TEST_F (line 22) | TEST_F(CIRCoreTest, NodeNoReplacementRTTI) { function TEST_F (line 38) | TEST_F(CIRCoreTest, NodeNoReplacementAttributes) { function TEST_F (line 48) | TEST_F(CIRCoreTest, NodeReplacementRTTI) { function TEST_F (line 61) | TEST_F(CIRCoreTest, NodeReplacementDelegates) { function TEST_F (line 86) | TEST_F(CIRCoreTest, NodeNonReplaceableFails) { FILE: test/cir/constant.cpp function TEST_F (line 8) | TEST_F(CIRCoreTest, ConstTypeQueryAndReplace) { function TEST_F (line 18) | TEST_F(CIRCoreTest, ConstCloning) { FILE: test/cir/flow.cpp function TEST_F (line 10) | TEST_F(CIRCoreTest, SeriesFlowInsertionEraseAndIterators) { function TEST_F (line 28) | TEST_F(CIRCoreTest, SeriesFlowQueryAndReplace) { function TEST_F (line 46) | TEST_F(CIRCoreTest, SeriesFlowCloning) { function TEST_F (line 57) | TEST_F(CIRCoreTest, WhileFlowQueryAndReplace) { function TEST_F (line 83) | TEST_F(CIRCoreTest, WhileFlowCloning) { function TEST_F (line 90) | TEST_F(CIRCoreTest, ForFlowQueryAndReplace) { function TEST_F (line 122) | TEST_F(CIRCoreTest, ForFlowCloning) { function TEST_F (line 131) | TEST_F(CIRCoreTest, IfFlowQueryAndReplace) { function TEST_F (line 172) | TEST_F(CIRCoreTest, IfFlowCloning) { function TEST_F (line 181) | TEST_F(CIRCoreTest, TryCatchFlowSingleCatchQueryAndReplace) { FILE: test/cir/func.cpp function TEST_F (line 9) | TEST_F(CIRCoreTest, FuncRealizationAndVarInsertionEraseAndIterators) { function TEST_F (line 32) | TEST_F(CIRCoreTest, BodiedFuncQueryAndReplace) { function TEST_F (line 55) | TEST_F(CIRCoreTest, BodiedFuncUnmangledName) { function TEST_F (line 62) | TEST_F(CIRCoreTest, BodiedFuncCloning) { function TEST_F (line 71) | TEST_F(CIRCoreTest, ExternalFuncUnmangledNameAndCloning) { function TEST_F (line 80) | TEST_F(CIRCoreTest, InternalFuncParentTypeUnmangledNameAndCloning) { function TEST_F (line 91) | TEST_F(CIRCoreTest, LLVMFuncUnmangledNameQueryAndReplace) { FILE: test/cir/instr.cpp function TEST_F (line 7) | TEST_F(CIRCoreTest, AssignInstrQueryAndReplace) { function TEST_F (line 28) | TEST_F(CIRCoreTest, AssignInstrCloning) { function TEST_F (line 36) | TEST_F(CIRCoreTest, ExtractInstrQueryAndReplace) { function TEST_F (line 55) | TEST_F(CIRCoreTest, ExtractInstrCloning) { function TEST_F (line 66) | TEST_F(CIRCoreTest, InsertInstrQueryAndReplace) { function TEST_F (line 86) | TEST_F(CIRCoreTest, InsertInstrCloning) { function TEST_F (line 99) | TEST_F(CIRCoreTest, CallInstrQueryAndReplace) { function TEST_F (line 114) | TEST_F(CIRCoreTest, CallInstrCloning) { function TEST_F (line 124) | TEST_F(CIRCoreTest, StackAllocInstrQueryAndReplace) { function TEST_F (line 141) | TEST_F(CIRCoreTest, StackAllocInstrCloning) { function TEST_F (line 148) | TEST_F(CIRCoreTest, TypePropertyInstrQueryAndReplace) { function TEST_F (line 168) | TEST_F(CIRCoreTest, TypePropertyInstrCloning) { function TEST_F (line 175) | TEST_F(CIRCoreTest, YieldInInstrQueryAndReplace) { function TEST_F (line 189) | TEST_F(CIRCoreTest, YieldInInstrCloning) { function TEST_F (line 195) | TEST_F(CIRCoreTest, TernaryInstrQueryAndReplace) { function TEST_F (line 215) | TEST_F(CIRCoreTest, TernaryInstrCloning) { function TEST_F (line 224) | TEST_F(CIRCoreTest, ContinueInstrQueryReplaceAndCloning) { function TEST_F (line 229) | TEST_F(CIRCoreTest, BreakInstrQueryReplaceAndCloning) { function TEST_F (line 234) | TEST_F(CIRCoreTest, ReturnInstrQueryReplaceAndCloning) { function TEST_F (line 246) | TEST_F(CIRCoreTest, YieldInstrQueryReplaceAndCloning) { function TEST_F (line 258) | TEST_F(CIRCoreTest, ThrowInstrQueryReplaceAndCloning) { function TEST_F (line 270) | TEST_F(CIRCoreTest, FlowInstrQueryAndReplace) { function TEST_F (line 285) | TEST_F(CIRCoreTest, FlowInstrCloning) { FILE: test/cir/module.cpp function TEST_F (line 7) | TEST_F(CIRCoreTest, ModuleNodeBuildingRemovalAndIterators) { function TEST_F (line 36) | TEST_F(CIRCoreTest, ModuleMainFunctionAndArgVar) { function TEST_F (line 52) | TEST_F(CIRCoreTest, ModuleTypeGetAndLookup) { FILE: test/cir/test.h function class (line 7) | class CIRCoreTest : public testing::Test { FILE: test/cir/transform/manager.cpp class DummyResult (line 11) | class DummyResult : public analyze::Result {} class DummyAnalysis (line 13) | class DummyAnalysis : public analyze::Analysis { method DummyAnalysis (line 20) | explicit DummyAnalysis(int &counter) : counter(counter) {} method getKey (line 22) | std::string getKey() const override { return ANALYSIS_KEY; } method run (line 24) | std::unique_ptr run(const Module *) override { class DummyPass (line 32) | class DummyPass : public transform::Pass { method DummyPass (line 40) | explicit DummyPass(int &counter, std::string required) method getKey (line 43) | std::string getKey() const override { return PASS_KEY; } method run (line 45) | void run(Module *) override { function TEST_F (line 53) | TEST_F(CIRCoreTest, PassManagerNoInvalidations) { function TEST_F (line 67) | TEST_F(CIRCoreTest, PassManagerInvalidations) { FILE: test/cir/types/types.cpp function TEST_F (line 7) | TEST_F(CIRCoreTest, RecordTypeQuery) { function TEST_F (line 27) | TEST_F(CIRCoreTest, RefTypeQuery) { function TEST_F (line 48) | TEST_F(CIRCoreTest, FuncTypeQuery) { FILE: test/cir/util/matching.cpp function TEST_F (line 7) | TEST_F(CIRCoreTest, MatchingEquivalentVar) { function TEST_F (line 15) | TEST_F(CIRCoreTest, MatchingNonEquivalentVar) { function TEST_F (line 21) | TEST_F(CIRCoreTest, MatchingEquivalentFunc) { function TEST_F (line 54) | TEST_F(CIRCoreTest, MatchingNonEquivalentFunc) { function TEST_F (line 88) | TEST_F(CIRCoreTest, MatchingAnyValue) { function TEST_F (line 93) | TEST_F(CIRCoreTest, MatchingVarValue) { function TEST_F (line 101) | TEST_F(CIRCoreTest, MatchingPointerValue) { function TEST_F (line 109) | TEST_F(CIRCoreTest, MatchingSeriesFlow) { function TEST_F (line 120) | TEST_F(CIRCoreTest, MatchingIfFlow) { function TEST_F (line 131) | TEST_F(CIRCoreTest, MatchingForFlow) { function TEST_F (line 144) | TEST_F(CIRCoreTest, MatchingIntConst) { function TEST_F (line 152) | TEST_F(CIRCoreTest, MatchingFloatConst) { function TEST_F (line 160) | TEST_F(CIRCoreTest, MatchingBoolConst) { function TEST_F (line 168) | TEST_F(CIRCoreTest, MatchingStringConst) { function TEST_F (line 176) | TEST_F(CIRCoreTest, MatchingAssignInstr) { function TEST_F (line 187) | TEST_F(CIRCoreTest, MatchingExtractInstr) { function TEST_F (line 201) | TEST_F(CIRCoreTest, MatchingInsertInstr) { function TEST_F (line 216) | TEST_F(CIRCoreTest, MatchingCallInstr) { function TEST_F (line 232) | TEST_F(CIRCoreTest, MatchingTernaryInstr) { FILE: test/cir/value.cpp function TEST_F (line 5) | TEST_F(CIRCoreTest, ValueQueryMethodsDelegate) { function TEST_F (line 33) | TEST_F(CIRCoreTest, ValueReplaceMethodsDelegate) { FILE: test/cir/var.cpp function TEST_F (line 5) | TEST_F(CIRCoreTest, VarQueryMethodsDelegate) { function TEST_F (line 14) | TEST_F(CIRCoreTest, VarReplaceMethodsDelegate) { FILE: test/main.cpp class TestOutliner (line 34) | class TestOutliner : public ir::transform::OperatorPass { method getKey (line 41) | std::string getKey() const override { return KEY; } method handle (line 43) | void handle(ir::SeriesFlow *v) override { method handle (line 67) | void handle(ir::ReturnInstr *v) override { class TestInliner (line 80) | class TestInliner : public ir::transform::OperatorPass { method getKey (line 82) | std::string getKey() const override { return KEY; } method handle (line 84) | void handle(ir::CallInstr *v) override { type PartitionArgsByEscape (line 104) | struct PartitionArgsByEscape : public ir::util::Operator { method handle (line 108) | void handle(ir::CallInstr *v) override { type EscapeValidator (line 140) | struct EscapeValidator : public ir::transform::Pass { method getKey (line 142) | std::string getKey() const override { return KEY; } method EscapeValidator (line 146) | explicit EscapeValidator(const std::string &capAnalysisKey) method run (line 149) | void run(ir::Module *m) override { function splitLines (line 184) | vector splitLines(const string &output) { function findExpectOnLine (line 196) | static pair findExpectOnLine(const string &line) { function findExpects (line 206) | static pair, bool> findExpects(const string &filename, bo... class SeqTest (line 241) | class SeqTest method SeqTest (line 251) | SeqTest() : buf(65536), out_pipe(), pid() {} method string (line 252) | string getFilename(const string &basename) { method runInChildProcess (line 255) | int runInChildProcess(bool avoidFork = false) { method string (line 324) | string result() { return string(buf.data()); } function string (line 326) | static string function string (line 343) | static string function TEST_P (line 347) | TEST_P(SeqTest, Run) { function getTypeTests (line 380) | auto getTypeTests(const vector &files) { function main (line 599) | int main(int argc, char *argv[]) { FILE: test/python/cython_jit.py class Foo (line 6) | class Foo: method __init__ (line 9) | def __init__(self, n): method __eq__ (line 14) | def __eq__(self, other): method __hash__ (line 19) | def __hash__(self): method total (line 23) | def total(self): method __init__ (line 126) | def __init__(self): function test_convertible (line 26) | def test_convertible(): function test_many (line 29) | def test_many(): function test_roundtrip (line 41) | def test_roundtrip(): function test_return_type (line 64) | def test_return_type(): function test_param_types (line 82) | def test_param_types(): function test_error_handling (line 94) | def test_error_handling(): function foo (line 117) | def foo(y): function foo2 (line 122) | def foo2(y): class Foo (line 125) | class Foo: method __init__ (line 9) | def __init__(self, n): method __eq__ (line 14) | def __eq__(self, other): method __hash__ (line 19) | def __hash__(self): method total (line 23) | def total(self): method __init__ (line 126) | def __init__(self): function a (line 130) | def a(x): function b (line 133) | def b(x, z): function c (line 138) | def c(x, y): function test_cross_calls (line 142) | def test_cross_calls(): function d (line 156) | def d(x, y): function test_ndarray (line 160) | def test_ndarray(): function e (line 186) | def e(x=2, y=99): function test_arg_order (line 189) | def test_arg_order(): FILE: test/python/find-python-library.py function get_python_library (line 3) | def get_python_library(python_version): FILE: test/python/mymodule.py function multiply (line 1) | def multiply(a,b): function print_args (line 4) | def print_args(a,b,c,d,e): function print_args_var (line 10) | def print_args_var(a,b,c=1,*args,**kwargs): function throw_exc (line 13) | def throw_exc(): function test_call_no_args (line 17) | def test_call_no_args(): function test_call_one_arg (line 20) | def test_call_one_arg(x): FILE: test/python/pyext.py function equal (line 4) | def equal(v, a, b, tag): function test_codon_extensions (line 15) | def test_codon_extensions(m): FILE: test/python/setup.py class CodonExtension (line 42) | class CodonExtension(Extension): method __init__ (line 43) | def __init__(self, name, source): class BuildCodonExt (line 47) | class BuildCodonExt(build_ext): method build_extensions (line 48) | def build_extensions(self): method run (line 51) | def run(self): method build_codon (line 59) | def build_codon(self, ext): FILE: test/types.cpp function TEST (line 21) | TEST(TypeCoreTest, TestName) { ; }