힙 공간에서 코드를 실행할 수 있나요?

아마도. 힙이 실행 가능하면 해당 코드로 분기할 수 있습니다. 그러나 일부 Unix 변형에서는힙 공간은 실행 가능하지 않습니다., 따라서 버퍼 오버플로와 같은 일부 보안 취약점을 악용하기가 더 어려워집니다(그러면 프로그램에 코드를 삽입할 수 있더라도 해당 프로그램으로 분기하지 못할 수 있습니다). (UNIX 변형 및 해당 구성에 대한 설명은 링크된 기사를 참조하십시오.) 또한 일부 프로세서 아키텍처에는코드와 데이터는 별도로 캐시됩니다.이므로 캐시 플러시 명령을 실행해야 할 수도 있습니다. 대체로 이것은 수동으로 수행하고 싶은 작업이 아닙니다.

로드된 코드를 실행 가능하게 만드는 작업을 수행하는 코드 로드 및 실행을 위한 표준 Unix API가 있습니다.떨어뜨리다. 코드는 파일에서 로드되어야 합니다.

적시 컴파일러일반적으로 dlopen보다 더 빠른 인터페이스를 찾으려고 노력합니다. 코드 실행 가능성을 보장하려면 고도로 플랫폼 의존적인 접근 방식을 관리해야 합니다.

_{편집 : 감사합니다브루스 에디거캐시를 새로 고쳐야 한다는 것을 상기시켜 줍니다.}

일부 하드웨어(예: HP의 HP-PA CPU)에서는 이것이 훨씬 더 어렵고 다른 하드웨어(예: DEC Alpha CPU)에서는 명령 캐시 플러시를 먼저 수행해야 하지만 일반적으로 말하면 힙에서 코드를 실행할 수 있습니다. 다음은 "힙에서" 코드를 실행하는 꽤 멋진 C 프로그램입니다.

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <unistd.h>

/* $Id: cpup4.c,v 1.2 1999/02/25 05:12:53 bediger Exp bediger $ */

typedef int (*fxptr)(
                int, int, int (*)(const char *, ...),
                void *,
                void *(*)(void *, const void *, size_t),
                void *(*)(size_t),
                void (*)(void *),
                size_t
);

char *signal_string(int sig);
void  signal_handler(int sig);
int   main(int ac, char **av);
int copyup(
                int i,
                int j,
                int (*xptr)(const char *, ...),
                void *yptr,
                void *(*bptr)(void *, const void *, size_t),
                void *(*mptr)(size_t),
                void (*ffptr)(void *),
                size_t  size
);
void f2(void);

/* return a string for the most common signals this program
 * will generate.  Probably could replace this with strerror()
 */
char *
signal_string(sig)
                int sig;
{
                char *bpr = "Don't know what signal";

                switch (sig)
                {
                case SIGILL:
                                bpr = "Illegal instruction";
                                break;
                case SIGSEGV:
                                bpr = "Segmentation violation";
                                break;
                case SIGBUS:
                                bpr = "Bus error";
                                break;
                }

                return bpr;
}

/* Use of fprintf() seems sketchy.  I think that signal_handler() doesn't
 * need special compiler treatment like generating Position Independent
 * Code.  It stays in one place, and the kernel knows that place.
 */
void
signal_handler(int sig)
{
                (void)fprintf(
                                stderr,
                                "%s: sig = 0x%x\n",
                                signal_string(sig),
                                sig
                );

                exit(99);
}

int
main(int ac, char **av)
{
                int i, j;

                /* check to see if cmd line has a number on it */
                if (ac < 2) {
                                printf("not enough arguments\n");
                                exit(99);
                }
                /* install 3 different signal handlers - avoid core dumps */
                if (-1 == (i = (long)signal(SIGSEGV, signal_handler)))
                {
                                perror("Installing SIGSEGV signal failed");
                                exit(33);
                }
                if (-1 == (i = (long)signal(SIGILL, signal_handler)))
                {
                                perror("Installing SIGILL signal handler failed");
                                exit(33);
                }
                if (-1 == (i = (long)signal(SIGBUS, signal_handler)))
                {
                                perror("Installing SIGBUS signal handler failed");
                                exit(33);
                }

                setbuf(stdout, NULL);

                /*
                 * print out addresses of original functions so there is something to
                 * reference during recursive function copying and calling 
                 */
                printf(
           "main = %p, copyup %p, memcpy %p, malloc %p, printf %p, free %p, size %ld\n",
           main, copyup, memcpy, malloc, printf, free, (size_t)f2 - (size_t)copyup);

                if ((i = atoi(*(av + 1))) < 1) {
                                printf(" i = %d, i must be > 1\n", i);
                                exit(99);
                }

                printf(" going for %d recursions\n", i);

                j = copyup(1, i, printf, copyup, memcpy, malloc, free, (size_t)f2 - (size_t)copyup);

                printf("copyup at %p returned %d\n", copyup, j);


                return 1;
}

int
copyup(
                int i, int j,
                int   (*xptr)(const char *, ...),
                void *yptr,
                void *(*bptr)(void *, const void*, size_t),
                void *(*mptr)(size_t),
                void  (*ffptr)(void *),
                size_t   size
)
{
                fxptr fptr;
                int k;

                if (i == j)
                {
                                (*xptr)("function at %p got to %d'th copy\n", yptr, i);
                                return i;
                } else
                                (*xptr)("function at %p, i = %d, j = %d\n", yptr, i, j);

                if (!(fptr = (fxptr)(*mptr)(size)))
                {
                                (*xptr)("ran out of memory allocating new function\n");
                                return -1;
                }

                (*bptr)(fptr, yptr, size);

                k = (*fptr)(i + 1, j, xptr, (void *)fptr, bptr, mptr, ffptr, size);

                (*xptr)("function at %p got %d back from function at %p\n",
                                yptr, k, fptr);

                (*ffptr)(fptr);

                return (k + 1);
}

void f2(void) {return;}