aboutsummaryrefslogtreecommitdiffstats
path: root/include/llvm/Support
diff options
context:
space:
mode:
Diffstat (limited to 'include/llvm/Support')
-rw-r--r--include/llvm/Support/CFG.h8
-rw-r--r--include/llvm/Support/Casting.h256
-rw-r--r--include/llvm/Support/InstIterator.h28
-rw-r--r--include/llvm/Support/InstVisitor.h92
4 files changed, 304 insertions, 80 deletions
diff --git a/include/llvm/Support/CFG.h b/include/llvm/Support/CFG.h
index db4c0c3..c2a4775 100644
--- a/include/llvm/Support/CFG.h
+++ b/include/llvm/Support/CFG.h
@@ -209,11 +209,11 @@ template <> struct GraphTraits<Inverse<const BasicBlock*> > {
// except that the root node is implicitly the first node of the function.
//
template <> struct GraphTraits<Function*> : public GraphTraits<BasicBlock*> {
- static NodeType *getEntryNode(Function *F) { return F->getEntryNode(); }
+ static NodeType *getEntryNode(Function *F) { return &F->getEntryNode(); }
};
template <> struct GraphTraits<const Function*> :
public GraphTraits<const BasicBlock*> {
- static NodeType *getEntryNode(const Function *F) { return F->getEntryNode(); }
+ static NodeType *getEntryNode(const Function *F) { return &F->getEntryNode();}
};
@@ -225,13 +225,13 @@ template <> struct GraphTraits<const Function*> :
template <> struct GraphTraits<Inverse<Function*> > :
public GraphTraits<Inverse<BasicBlock*> > {
static NodeType *getEntryNode(Inverse<Function*> G) {
- return G.Graph->front();
+ return &G.Graph->getEntryNode();
}
};
template <> struct GraphTraits<Inverse<const Function*> > :
public GraphTraits<Inverse<const BasicBlock*> > {
static NodeType *getEntryNode(Inverse<const Function *> G) {
- return G.Graph->front();
+ return &G.Graph->getEntryNode();
}
};
diff --git a/include/llvm/Support/Casting.h b/include/llvm/Support/Casting.h
index e59b7c2..2c072d1 100644
--- a/include/llvm/Support/Casting.h
+++ b/include/llvm/Support/Casting.h
@@ -8,51 +8,196 @@
#ifndef SUPPORT_CASTING_H
#define SUPPORT_CASTING_H
-// real_type - Provide a macro to get the real type of a value that might be
-// a use. This provides a typedef 'Type' that is the argument type for all
-// non UseTy types, and is the contained pointer type of the use if it is a
-// UseTy.
-//
-template <class X> class real_type { typedef X Type; };
+#include <assert.h>
//===----------------------------------------------------------------------===//
-// Type Checking Templates
+// isa<x> Support Templates
//===----------------------------------------------------------------------===//
+template<typename FromCl> struct isa_impl_cl;
+
+// Define a template that can be specialized by smart pointers to reflect the
+// fact that they are automatically dereferenced, and are not involved with the
+// template selection process... the default implementation is a noop.
+//
+template<typename From> struct simplify_type {
+ typedef From SimpleType; // The real type this represents...
+
+ // An accessor to get the real value...
+ static SimpleType &getSimplifiedValue(From &Val) { return Val; }
+};
+
+template<typename From> struct simplify_type<const From> {
+ typedef const From SimpleType;
+ static SimpleType &getSimplifiedValue(const From &Val) {
+ return simplify_type<From>::getSimplifiedValue((From&)Val);
+ }
+};
+
+
// isa<X> - Return true if the parameter to the template is an instance of the
// template type argument. Used like this:
//
-// if (isa<Type>(myVal)) { ... }
+// if (isa<Type*>(myVal)) { ... }
+//
+template <typename To, typename From>
+inline bool isa_impl(const From &Val) {
+ return To::classof(&Val);
+}
+
+template<typename To, typename From, typename SimpleType>
+struct isa_impl_wrap {
+ // When From != SimplifiedType, we can simplify the type some more by using
+ // the simplify_type template.
+ static bool doit(const From &Val) {
+ return isa_impl_cl<const SimpleType>::template
+ isa<To>(simplify_type<const From>::getSimplifiedValue(Val));
+ }
+};
+
+template<typename To, typename FromTy>
+struct isa_impl_wrap<To, const FromTy, const FromTy> {
+ // When From == SimpleType, we are as simple as we are going to get.
+ static bool doit(const FromTy &Val) {
+ return isa_impl<To,FromTy>(Val);
+ }
+};
+
+// isa_impl_cl - Use class partial specialization to transform types to a single
+// cannonical form for isa_impl.
//
+template<typename FromCl>
+struct isa_impl_cl {
+ template<class ToCl>
+ static bool isa(const FromCl &Val) {
+ return isa_impl_wrap<ToCl,const FromCl,
+ simplify_type<const FromCl>::SimpleType>::doit(Val);
+ }
+};
+
+// Specialization used to strip const qualifiers off of the FromCl type...
+template<typename FromCl>
+struct isa_impl_cl<const FromCl> {
+ template<class ToCl>
+ static bool isa(const FromCl &Val) {
+ return isa_impl_cl<FromCl>::template isa<ToCl>(Val);
+ }
+};
+
+// Define pointer traits in terms of base traits...
+template<class FromCl>
+struct isa_impl_cl<FromCl*> {
+ template<class ToCl>
+ static bool isa(FromCl *Val) {
+ return isa_impl_cl<FromCl>::template isa<ToCl>(*Val);
+ }
+};
+
+// Define reference traits in terms of base traits...
+template<class FromCl>
+struct isa_impl_cl<FromCl&> {
+ template<class ToCl>
+ static bool isa(FromCl &Val) {
+ return isa_impl_cl<FromCl>::template isa<ToCl>(&Val);
+ }
+};
+
template <class X, class Y>
-inline bool isa(Y Val) {
- assert(Val && "isa<Ty>(NULL) invoked!");
- return X::classof(Val);
+inline bool isa(const Y &Val) {
+ return isa_impl_cl<Y>::template isa<X>(Val);
}
+//===----------------------------------------------------------------------===//
+// cast<x> Support Templates
+//===----------------------------------------------------------------------===//
+
+template<class To, class From> struct cast_retty;
+
+
+// Calculate what type the 'cast' function should return, based on a requested
+// type of To and a source type of From.
+template<class To, class From> struct cast_retty_impl {
+ typedef To& ret_type; // Normal case, return Ty&
+};
+template<class To, class From> struct cast_retty_impl<To, const From> {
+ typedef const To &ret_type; // Normal case, return Ty&
+};
+
+template<class To, class From> struct cast_retty_impl<To, From*> {
+ typedef To* ret_type; // Pointer arg case, return Ty*
+};
+
+template<class To, class From> struct cast_retty_impl<To, const From*> {
+ typedef const To* ret_type; // Constant pointer arg case, return const Ty*
+};
+
+template<class To, class From> struct cast_retty_impl<To, const From*const> {
+ typedef const To* ret_type; // Constant pointer arg case, return const Ty*
+};
+
+
+template<class To, class From, class SimpleFrom>
+struct cast_retty_wrap {
+ // When the simplified type and the from type are not the same, use the type
+ // simplifier to reduce the type, then reuse cast_retty_impl to get the
+ // resultant type.
+ typedef typename cast_retty<To, SimpleFrom>::ret_type ret_type;
+};
+
+template<class To, class FromTy>
+struct cast_retty_wrap<To, FromTy, FromTy> {
+ // When the simplified type is equal to the from type, use it directly.
+ typedef typename cast_retty_impl<To,FromTy>::ret_type ret_type;
+};
+
+template<class To, class From>
+struct cast_retty {
+ typedef typename cast_retty_wrap<To, From,
+ simplify_type<From>::SimpleType>::ret_type ret_type;
+};
+
+// Ensure the non-simple values are converted using the simplify_type template
+// that may be specialized by smart pointers...
+//
+template<class To, class From, class SimpleFrom> struct cast_convert_val {
+ // This is not a simple type, use the template to simplify it...
+ static cast_retty<To, From>::ret_type doit(const From &Val) {
+ return cast_convert_val<To, SimpleFrom,
+ simplify_type<SimpleFrom>::SimpleType>::doit(
+ simplify_type<From>::getSimplifiedValue(Val));
+ }
+};
+
+template<class To, class FromTy> struct cast_convert_val<To,FromTy,FromTy> {
+ // This _is_ a simple type, just cast it.
+ static cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
+ return (cast_retty<To, FromTy>::ret_type)Val;
+ }
+};
+
+
// cast<X> - Return the argument parameter cast to the specified type. This
// casting operator asserts that the type is correct, so it does not return null
// on failure. But it will correctly return NULL when the input is NULL.
// Used Like this:
//
-// cast< Instruction>(myVal)->getParent()
-// cast<const Instruction>(myVal)->getParent()
+// cast<Instruction>(myVal)->getParent()
//
template <class X, class Y>
-inline X *cast(Y Val) {
+inline cast_retty<X, Y>::ret_type cast(const Y &Val) {
assert(isa<X>(Val) && "cast<Ty>() argument of uncompatible type!");
- return (X*)(real_type<Y>::Type)Val;
+ return cast_convert_val<X, Y, simplify_type<Y>::SimpleType>::doit(Val);
}
// cast_or_null<X> - Functionally identical to cast, except that a null value is
// accepted.
//
template <class X, class Y>
-inline X *cast_or_null(Y Val) {
- assert((Val == 0 || isa<X>(Val)) &&
- "cast_or_null<Ty>() argument of uncompatible type!");
- return (X*)(real_type<Y>::Type)Val;
+inline cast_retty<X, Y*>::ret_type cast_or_null(Y *Val) {
+ if (Val == 0) return 0;
+ assert(isa<X>(Val) && "cast_or_null<Ty>() argument of uncompatible type!");
+ return cast<X>(Val);
}
@@ -65,16 +210,81 @@ inline X *cast_or_null(Y Val) {
//
template <class X, class Y>
-inline X *dyn_cast(Y Val) {
- return isa<X>(Val) ? cast<X>(Val) : 0;
+inline cast_retty<X, Y*>::ret_type dyn_cast(Y *Val) {
+ return isa<X>(Val) ? cast<X, Y*>(Val) : 0;
}
// dyn_cast_or_null<X> - Functionally identical to dyn_cast, except that a null
// value is accepted.
//
template <class X, class Y>
-inline X *dyn_cast_or_null(Y Val) {
- return (Val && isa<X>(Val)) ? cast<X>(Val) : 0;
+inline cast_retty<X, Y*>::ret_type dyn_cast_or_null(Y *Val) {
+ return (Val && isa<X>(Val)) ? cast<X, Y*>(Val) : 0;
+}
+
+
+#ifdef DEBUG_CAST_OPERATORS
+#include <iostream>
+
+struct bar {
+ bar() {}
+private:
+ bar(const bar &);
+};
+struct foo {
+ void ext() const;
+ /* static bool classof(const bar *X) {
+ cerr << "Classof: " << X << "\n";
+ return true;
+ }*/
+};
+
+template <> inline bool isa_impl<foo,bar>(const bar &Val) {
+ cerr << "Classof: " << &Val << "\n";
+ return true;
+}
+
+
+bar *fub();
+void test(bar &B1, const bar *B2) {
+ // test various configurations of const
+ const bar &B3 = B1;
+ const bar *const B4 = B2;
+
+ // test isa
+ if (!isa<foo>(B1)) return;
+ if (!isa<foo>(B2)) return;
+ if (!isa<foo>(B3)) return;
+ if (!isa<foo>(B4)) return;
+
+ // test cast
+ foo &F1 = cast<foo>(B1);
+ const foo *F3 = cast<foo>(B2);
+ const foo *F4 = cast<foo>(B2);
+ const foo &F8 = cast<foo>(B3);
+ const foo *F9 = cast<foo>(B4);
+ foo *F10 = cast<foo>(fub());
+
+ // test cast_or_null
+ const foo *F11 = cast_or_null<foo>(B2);
+ const foo *F12 = cast_or_null<foo>(B2);
+ const foo *F13 = cast_or_null<foo>(B4);
+ const foo *F14 = cast_or_null<foo>(fub()); // Shouldn't print.
+
+ // These lines are errors...
+ //foo *F20 = cast<foo>(B2); // Yields const foo*
+ //foo &F21 = cast<foo>(B3); // Yields const foo&
+ //foo *F22 = cast<foo>(B4); // Yields const foo*
+ //foo &F23 = cast_or_null<foo>(B1);
+ //const foo &F24 = cast_or_null<foo>(B3);
+}
+
+bar *fub() { return 0; }
+void main() {
+ bar B;
+ test(B, &B);
}
#endif
+
+#endif
diff --git a/include/llvm/Support/InstIterator.h b/include/llvm/Support/InstIterator.h
index b2b1058..eb64113 100644
--- a/include/llvm/Support/InstIterator.h
+++ b/include/llvm/Support/InstIterator.h
@@ -35,22 +35,22 @@ public:
typedef IIty reference;
template<class M> InstIterator(M &m)
- : BBs(m.getBasicBlocks()), BB(BBs.begin()) { // begin ctor
+ : BBs(m.getBasicBlockList()), BB(BBs.begin()) { // begin ctor
if (BB != BBs.end()) {
- BI = (*BB)->begin();
+ BI = BB->begin();
advanceToNextBB();
}
}
template<class M> InstIterator(M &m, bool)
- : BBs(m.getBasicBlocks()), BB(BBs.end()) { // end ctor
+ : BBs(m.getBasicBlockList()), BB(BBs.end()) { // end ctor
}
// Accessors to get at the underlying iterators...
inline BBIty &getBasicBlockIterator() { return BB; }
inline BIty &getInstructionIterator() { return BI; }
- inline IIty operator*() const { return *BI; }
+ inline IIty operator*() const { return &*BI; }
inline IIty operator->() const { return operator*(); }
inline bool operator==(const InstIterator &y) const {
@@ -70,9 +70,9 @@ public:
}
InstIterator& operator--() {
- while (BB == BBs.end() || BI == (*BB)->begin()) {
+ while (BB == BBs.end() || BI == BB->begin()) {
--BB;
- BI = (*BB)->end();
+ BI = BB->end();
}
--BI;
return *this;
@@ -87,19 +87,19 @@ private:
inline void advanceToNextBB() {
// The only way that the II could be broken is if it is now pointing to
// the end() of the current BasicBlock and there are successor BBs.
- while (BI == (*BB)->end()) {
+ while (BI == BB->end()) {
++BB;
if (BB == BBs.end()) break;
- BI = (*BB)->begin();
+ BI = BB->begin();
}
}
};
-typedef InstIterator<ValueHolder<BasicBlock, Function, Function>,
+typedef InstIterator<iplist<BasicBlock>,
Function::iterator, BasicBlock::iterator,
Instruction*> inst_iterator;
-typedef InstIterator<const ValueHolder<BasicBlock, Function, Function>,
+typedef InstIterator<const iplist<BasicBlock>,
Function::const_iterator,
BasicBlock::const_iterator,
const Instruction*> const_inst_iterator;
@@ -112,5 +112,13 @@ inline const_inst_iterator inst_begin(const Function *F) {
inline const_inst_iterator inst_end(const Function *F) {
return const_inst_iterator(*F, true);
}
+inline inst_iterator inst_begin(Function &F) { return inst_iterator(F); }
+inline inst_iterator inst_end(Function &F) { return inst_iterator(F, true); }
+inline const_inst_iterator inst_begin(const Function &F) {
+ return const_inst_iterator(F);
+}
+inline const_inst_iterator inst_end(const Function &F) {
+ return const_inst_iterator(F, true);
+}
#endif
diff --git a/include/llvm/Support/InstVisitor.h b/include/llvm/Support/InstVisitor.h
index fdf6731..883a6fe 100644
--- a/include/llvm/Support/InstVisitor.h
+++ b/include/llvm/Support/InstVisitor.h
@@ -57,7 +57,7 @@ class AllocationInst; class MemAccessInst;
#define DELEGATE(CLASS_TO_VISIT) \
- return ((SubClass*)this)->visit##CLASS_TO_VISIT((CLASS_TO_VISIT*)I)
+ return ((SubClass*)this)->visit##CLASS_TO_VISIT((CLASS_TO_VISIT&)I)
template<typename SubClass, typename RetTy=void>
@@ -78,26 +78,32 @@ struct InstVisitor {
// Define visitors for modules, functions and basic blocks...
//
- void visit(Module *M) {
+ void visit(Module &M) {
((SubClass*)this)->visitModule(M);
- visit(M->begin(), M->end());
+ visit(M.begin(), M.end());
}
- void visit(Function *F) {
+ void visit(Function &F) {
((SubClass*)this)->visitFunction(F);
- visit(F->begin(), F->end());
+ visit(F.begin(), F.end());
}
- void visit(BasicBlock *BB) {
+ void visit(BasicBlock &BB) {
((SubClass*)this)->visitBasicBlock(BB);
- visit(BB->begin(), BB->end());
+ visit(BB.begin(), BB.end());
}
+ // Forwarding functions so that the user can visit with pointers AND refs.
+ void visit(Module *M) { visit(*M); }
+ void visit(Function *F) { visit(*F); }
+ void visit(BasicBlock *BB) { visit(*BB); }
+ RetTy visit(Instruction *I) { return visit(*I); }
+
// visit - Finally, code to visit an instruction...
//
- RetTy visit(Instruction *I) {
- switch (I->getOpcode()) {
+ RetTy visit(Instruction &I) {
+ switch (I.getOpcode()) {
// Build the switch statement using the Instruction.def file...
#define HANDLE_INST(NUM, OPCODE, CLASS) \
- case Instruction::OPCODE:return ((SubClass*)this)->visit##OPCODE((CLASS*)I);
+ case Instruction::OPCODE:return ((SubClass*)this)->visit##OPCODE((CLASS&)I);
#include "llvm/Instruction.def"
default: assert(0 && "Unknown instruction type encountered!");
@@ -116,9 +122,9 @@ struct InstVisitor {
// When visiting a module, function or basic block directly, these methods get
// called to indicate when transitioning into a new unit.
//
- void visitModule (Module *M) {}
- void visitFunction (Function *F) {}
- void visitBasicBlock(BasicBlock *BB) {}
+ void visitModule (Module &M) {}
+ void visitFunction (Function &F) {}
+ void visitBasicBlock(BasicBlock &BB) {}
// Define instruction specific visitor functions that can be overridden to
@@ -133,49 +139,49 @@ struct InstVisitor {
// this, we do not autoexpand "Other" instructions, we do it manually.
//
#define HANDLE_INST(NUM, OPCODE, CLASS) \
- RetTy visit##OPCODE(CLASS *I) { DELEGATE(CLASS); }
+ RetTy visit##OPCODE(CLASS &I) { DELEGATE(CLASS); }
#define HANDLE_OTHER_INST(NUM, OPCODE, CLASS) // Ignore "other" instructions
#include "llvm/Instruction.def"
// Implement all "other" instructions, except for PHINode
- RetTy visitCast(CastInst *I) { DELEGATE(CastInst); }
- RetTy visitCall(CallInst *I) { DELEGATE(CallInst); }
- RetTy visitShr(ShiftInst *I) { DELEGATE(ShiftInst); }
- RetTy visitShl(ShiftInst *I) { DELEGATE(ShiftInst); }
- RetTy visitUserOp1(Instruction *I) { DELEGATE(Instruction); }
- RetTy visitUserOp2(Instruction *I) { DELEGATE(Instruction); }
+ RetTy visitCast(CastInst &I) { DELEGATE(CastInst); }
+ RetTy visitCall(CallInst &I) { DELEGATE(CallInst); }
+ RetTy visitShr(ShiftInst &I) { DELEGATE(ShiftInst); }
+ RetTy visitShl(ShiftInst &I) { DELEGATE(ShiftInst); }
+ RetTy visitUserOp1(Instruction &I) { DELEGATE(Instruction); }
+ RetTy visitUserOp2(Instruction &I) { DELEGATE(Instruction); }
// Specific Instruction type classes... note that all of the casts are
// neccesary because we use the instruction classes as opaque types...
//
- RetTy visitReturnInst(ReturnInst *I) { DELEGATE(TerminatorInst);}
- RetTy visitBranchInst(BranchInst *I) { DELEGATE(TerminatorInst);}
- RetTy visitSwitchInst(SwitchInst *I) { DELEGATE(TerminatorInst);}
- RetTy visitInvokeInst(InvokeInst *I) { DELEGATE(TerminatorInst);}
- RetTy visitGenericUnaryInst(GenericUnaryInst *I) { DELEGATE(UnaryOperator); }
- RetTy visitGenericBinaryInst(GenericBinaryInst *I){ DELEGATE(BinaryOperator);}
- RetTy visitSetCondInst(SetCondInst *I) { DELEGATE(BinaryOperator);}
- RetTy visitMallocInst(MallocInst *I) { DELEGATE(AllocationInst);}
- RetTy visitAllocaInst(AllocaInst *I) { DELEGATE(AllocationInst);}
- RetTy visitFreeInst(FreeInst *I) { DELEGATE(Instruction); }
- RetTy visitLoadInst(LoadInst *I) { DELEGATE(MemAccessInst); }
- RetTy visitStoreInst(StoreInst *I) { DELEGATE(MemAccessInst); }
- RetTy visitGetElementPtrInst(GetElementPtrInst *I){ DELEGATE(MemAccessInst); }
- RetTy visitPHINode(PHINode *I) { DELEGATE(Instruction); }
- RetTy visitCastInst(CastInst *I) { DELEGATE(Instruction); }
- RetTy visitCallInst(CallInst *I) { DELEGATE(Instruction); }
- RetTy visitShiftInst(ShiftInst *I) { DELEGATE(Instruction); }
+ RetTy visitReturnInst(ReturnInst &I) { DELEGATE(TerminatorInst);}
+ RetTy visitBranchInst(BranchInst &I) { DELEGATE(TerminatorInst);}
+ RetTy visitSwitchInst(SwitchInst &I) { DELEGATE(TerminatorInst);}
+ RetTy visitInvokeInst(InvokeInst &I) { DELEGATE(TerminatorInst);}
+ RetTy visitGenericUnaryInst(GenericUnaryInst &I) { DELEGATE(UnaryOperator); }
+ RetTy visitGenericBinaryInst(GenericBinaryInst &I){ DELEGATE(BinaryOperator);}
+ RetTy visitSetCondInst(SetCondInst &I) { DELEGATE(BinaryOperator);}
+ RetTy visitMallocInst(MallocInst &I) { DELEGATE(AllocationInst);}
+ RetTy visitAllocaInst(AllocaInst &I) { DELEGATE(AllocationInst);}
+ RetTy visitFreeInst(FreeInst &I) { DELEGATE(Instruction); }
+ RetTy visitLoadInst(LoadInst &I) { DELEGATE(MemAccessInst); }
+ RetTy visitStoreInst(StoreInst &I) { DELEGATE(MemAccessInst); }
+ RetTy visitGetElementPtrInst(GetElementPtrInst &I){ DELEGATE(MemAccessInst); }
+ RetTy visitPHINode(PHINode &I) { DELEGATE(Instruction); }
+ RetTy visitCastInst(CastInst &I) { DELEGATE(Instruction); }
+ RetTy visitCallInst(CallInst &I) { DELEGATE(Instruction); }
+ RetTy visitShiftInst(ShiftInst &I) { DELEGATE(Instruction); }
// Next level propogators... if the user does not overload a specific
// instruction type, they can overload one of these to get the whole class
// of instructions...
//
- RetTy visitTerminatorInst(TerminatorInst *I) { DELEGATE(Instruction); }
- RetTy visitUnaryOperator (UnaryOperator *I) { DELEGATE(Instruction); }
- RetTy visitBinaryOperator(BinaryOperator *I) { DELEGATE(Instruction); }
- RetTy visitAllocationInst(AllocationInst *I) { DELEGATE(Instruction); }
- RetTy visitMemAccessInst (MemAccessInst *I) { DELEGATE(Instruction); }
+ RetTy visitTerminatorInst(TerminatorInst &I) { DELEGATE(Instruction); }
+ RetTy visitUnaryOperator (UnaryOperator &I) { DELEGATE(Instruction); }
+ RetTy visitBinaryOperator(BinaryOperator &I) { DELEGATE(Instruction); }
+ RetTy visitAllocationInst(AllocationInst &I) { DELEGATE(Instruction); }
+ RetTy visitMemAccessInst (MemAccessInst &I) { DELEGATE(Instruction); }
// If the user wants a 'default' case, they can choose to override this
// function. If this function is not overloaded in the users subclass, then
@@ -183,7 +189,7 @@ struct InstVisitor {
//
// Note that you MUST override this function if your return type is not void.
//
- void visitInstruction(Instruction *I) {} // Ignore unhandled instructions
+ void visitInstruction(Instruction &I) {} // Ignore unhandled instructions
};
#undef DELEGATE
generated by cgit v1.1 at 2025-08-15 20:19:34 +0000