SEL, IMP, Method: The Three Core Elements of Objective-C Runtime — A Deep Dive

The Underlying Nature of Method

In the runtime source code, Method is defined as:

// From objc4 runtime source (objc_runtime_new.h)
struct objc_method {
    SEL method_name;           // Method name (the "index" in the method table)
    const char *method_types;  // Type encoding string (parameter + return types)
    IMP method_imp;            // Function pointer (the actual implementation)
};

// method_types examples:
// "v@:"  = void return, id self, SEL _cmd
// "i@:@i" = int return, id self, SEL _cmd, id param, int param

Method is a struct that packages a SEL, an IMP, and method type encoding together. It’s the complete description of a method: what it’s called (SEL), how it’s called (type encoding), and what its implementation is (IMP).

The method type encoding (method_types) is a string that describes the parameter types and return type. "v@:" means void return, id self, SEL _cmd. "i@:@i" means int return, id self, SEL _cmd, id parameter, int parameter.

// Print a method's type encoding
Method method = class_getInstanceMethod([NSString class], @selector(appendString:));
const char *types = method_getTypeEncoding(method);
NSLog(@"%s", types);  // Outputs something like "v@:@"

The Collaborative Relationship

objc_msgSend‘s lookup process is the complete collaboration flow of these three elements:

1. Receive receiver and SEL
2. Find the class object through receiver->isa
3. Look up SEL in the class's method cache
   → Hit → Get IMP directly → Jump and execute
   → Miss → Traverse the method list
4. Iterate through Methods in the method list, comparing method_name to SEL
5. Once a matching Method is found, extract method_imp
6. Jump to IMP and execute
7. Store the SEL-IMP pair in the cache

Method is the “entry” in the method table, SEL is the “index,” and IMP is the “data.” A class’s method table is essentially a SEL→IMP mapping table, but each mapping also carries type encoding information — so it’s carried by the Method struct.

class_addMethod does this: packages the given SEL and IMP into a new Method, then inserts it into the class’s method table. method_exchangeImplementations simply swaps the method_imp pointers of two Methods, leaving the SEL and type encoding unchanged.

Source Code Evidence: The Collaboration During Lookup

In the lookUpImpOrForward function, you can clearly see the collaboration:

// Simplified logic from lookUpImpOrForward (objc-runtime-new.m)
IMP lookUpImpOrForward(id obj, SEL sel) {
    Class cls = obj->getIsa();           // Step 1: Get the class via isa

    // Step 2: Check the method cache first (O(1) lookup)
    IMP imp = cache_get(cls, sel);
    if (imp != NULL) return imp;         // Cache hit — return immediately

    // Step 3: Cache miss — traverse the method list
    method_list_t *methods = cls->data()->methods;
    for (method_t *m : methods) {
        if (m->method_name == sel) {     // Compare SEL pointer (not string!)
            imp = m->method_imp;         // Extract the IMP
            cache_set(cls, sel, imp);    // Store in cache for next time
            return imp;
        }
    }

    // Step 4: Not found — trigger dynamic resolution or forwarding
    return resolveMethod(cls, sel);
}

Although the actual implementation uses more complex binary search and cache optimizations, the core logic remains: use SEL to find Method in the method list, then extract the IMP from it.

What Each Concept Is Used For

SEL is used wherever you need to “represent a method name” — for example, @selector, NSSelectorFromString, -respondsToSelector:, -performSelector:, and the first argument to class_getInstanceMethod.

IMP is used when you need to “directly call a method implementation” — for example, bypassing message sending in performance-sensitive scenarios, or as an argument to class_addMethod during dynamic method resolution.

Method is used when you need to “operate on an entire method definition” — for example, method_exchangeImplementations to swap two methods, or class_replaceMethod to replace a method implementation.

Summary

The distinction between SEL, IMP, and Method:

• SEL is the method name — a globally unique string identifier, responsible only for “what it’s called,” not “who owns it”
• IMP is the function pointer — points to the method implementation’s starting address, responsible for “how it works” — the code that actually executes
• Method is the struct — packages SEL, type encoding, and IMP together, representing the complete definition

The collaborative relationship: a class maintains a method table where each entry is a Method, and the system finds the corresponding Method through the SEL, then extracts the IMP and executes it. The dictionary analogy still holds — SEL is the word you’re looking up, Method is the dictionary entry, IMP is the definition.