methods.c

/* GNU Objective C Runtime method related functions.
 Copyright (C) 2010-2025 Free Software Foundation, Inc.
 Contributed by Nicola Pero

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 3, or (at your option) any later version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
details.

Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.

You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */

#include"objc-private/common.h"
#include"objc/runtime.h"
#include"objc-private/module-abi-8.h"/* For runtime structures. */
#include"objc/thr.h"
#include"objc-private/runtime.h"/* For __objc_runtime_mutex. */
#include<stdlib.h>/* For malloc. */

SEL
method_getName (structobjc_method*method)
{
if (method==NULL)
returnNULL;

returnmethod->method_name;
}

constchar*
method_getTypeEncoding (structobjc_method*method)
{
if (method==NULL)
returnNULL;

returnmethod->method_types;
}

IMP
method_getImplementation (structobjc_method*method)
{
if (method==NULL)
returnNULL;

returnmethod->method_imp;
}

structobjc_method_description*
method_getDescription (structobjc_method*method)
{
/* Note that the following returns NULL if method is NULL, which is
 fine. */
return (structobjc_method_description*)method;
}

structobjc_method**
class_copyMethodList (Classclass_, unsigned int*numberOfReturnedMethods)
{
unsigned intcount=0;
structobjc_method**returnValue=NULL;
structobjc_method_list*method_list;

if (class_==Nil)
 {
if (numberOfReturnedMethods)
*numberOfReturnedMethods=0;
returnNULL;
 }

/* Lock the runtime mutex because the class methods may be
 concurrently modified. */
objc_mutex_lock (__objc_runtime_mutex);

/* Count how many methods we have. */
method_list=class_->methods;

while (method_list)
 {
count=count+method_list->method_count;
method_list=method_list->method_next;
 }

if (count!=0)
 {
unsigned inti=0;

/* Allocate enough memory to hold them. */
returnValue
= (structobjc_method**)(malloc (sizeof (structobjc_method*) 
* (count+1)));

/* Copy the methods. */
method_list=class_->methods;

while (method_list)
 {
intj;
for (j=0; j<method_list->method_count; j++)
 {
returnValue[i] =&(method_list->method_list[j]);
i++;
 }
method_list=method_list->method_next;
 }

returnValue[i] =NULL;
 }

objc_mutex_unlock (__objc_runtime_mutex);

if (numberOfReturnedMethods)
*numberOfReturnedMethods=count;

returnreturnValue;
}

IMP
method_setImplementation (structobjc_method*method, IMPimplementation)
{
IMPold_implementation;

if (method==NULL||implementation==NULL)
returnNULL;

/* We lock the runtime mutex so that concurrent calls to change the
 same method won't conflict with each other. */
objc_mutex_lock (__objc_runtime_mutex);

old_implementation=method->method_imp;
method->method_imp=implementation;

/* That was easy :-). But now we need to find all classes that use
 this method, and update the IMP in the dispatch tables. */
__objc_update_classes_with_methods (method, NULL);

objc_mutex_unlock (__objc_runtime_mutex);

returnold_implementation;
}

void
method_exchangeImplementations (structobjc_method*method_a, structobjc_method*method_b)
{
IMPold_implementation_a;
IMPold_implementation_b;

if (method_a==NULL||method_b==NULL)
return;

/* We lock the runtime mutex so that concurrent calls to exchange
 similar methods won't conflict with each other. Each of them
 should be atomic. */
objc_mutex_lock (__objc_runtime_mutex);

old_implementation_a=method_a->method_imp;
old_implementation_b=method_b->method_imp;

method_a->method_imp=old_implementation_b;
method_b->method_imp=old_implementation_a;

/* That was easy :-). But now we need to find all classes that use
 these methods, and update the IMP in the dispatch tables. */
__objc_update_classes_with_methods (method_a, method_b);

objc_mutex_unlock (__objc_runtime_mutex);
}