/* GNU Objective C Runtime method related functions.   Copyright (C) 2010-2026 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 theterms of the GNU General Public License as published by the Free SoftwareFoundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANYWARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESSFOR A PARTICULAR PURPOSE.  See the GNU General Public License for moredetails. Under Section 7 of GPL version 3, you are granted additionalpermissions described in the GCC Runtime Library Exception, version3.1, as published by the Free Software Foundation. You should have received a copy of the GNU General Public License anda 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.  */ SELmethod_getName (struct objc_method * method){  if (method == NULL)    return NULL;   return method->method_name;} const char *method_getTypeEncoding (struct objc_method * method){  if (method == NULL)    return NULL;   return method->method_types;} IMPmethod_getImplementation (struct objc_method * method){  if (method == NULL)    return NULL;   return method->method_imp;} struct objc_method_description *method_getDescription (struct objc_method * method){  /* Note that the following returns NULL if method is NULL, which is     fine.  */  return (struct objc_method_description *)method;} struct objc_method **class_copyMethodList (Class class_, unsigned int *numberOfReturnedMethods){  unsigned int count = 0;  struct objc_method **returnValue = NULL;  struct objc_method_list* method_list;   if (class_ == Nil)    {      if (numberOfReturnedMethods)	*numberOfReturnedMethods = 0;      return NULL;    }   /* 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 int i = 0;            /* Allocate enough memory to hold them.  */      returnValue 	= (struct objc_method **)(malloc (sizeof (struct objc_method *) 					  * (count + 1)));            /* Copy the methods.  */      method_list = class_->methods;            while (method_list)	{	  int j;	  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;   return returnValue;} IMPmethod_setImplementation (struct objc_method * method, IMP implementation){  IMP old_implementation;   if (method == NULL  ||  implementation == NULL)    return NULL;   /* 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);   return old_implementation;} voidmethod_exchangeImplementations (struct objc_method * method_a, struct objc_method * method_b){  IMP old_implementation_a;  IMP old_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);}