랄라라

struct addrinfo {
    int              ai_flags;     // AI_PASSIVE, AI_CANONNAME, etc.
    int              ai_family;    // AF_INET, AF_INET6, AF_UNSPEC
    int              ai_socktype;  // SOCK_STREAM, SOCK_DGRAM
    int              ai_protocol;  // use 0 for "any"
    size_t           ai_addrlen;   // size of ai_addr in bytes
    struct sockaddr *ai_addr;      // struct sockaddr_in or _in6
    char            *ai_canonname; // full canonical hostname

    struct addrinfo *ai_next;      // linked list, next node
};

struct sockaddr {
    unsigned short    sa_family;    // address family, AF_xxx
    char              sa_data[14];  // 14 bytes of protocol address
}; 

// (IPv4 only--see struct sockaddr_in6 for IPv6)

struct sockaddr_in {
    short int          sin_family;  // Address family, AF_INET
    unsigned short int sin_port;    // Port number
    struct in_addr     sin_addr;    // Internet address
    unsigned char      sin_zero[8]; // Same size as struct sockaddr
};

// (IPv4 only--see struct in6_addr for IPv6)

// Internet address (a structure for historical reasons)
struct in_addr {
    uint32_t s_addr; // that's a 32-bit int (4 bytes)
};

// (IPv6 only--see struct sockaddr_in and struct in_addr for IPv4)

struct sockaddr_in6 {
    u_int16_t       sin6_family;   // address family, AF_INET6
    u_int16_t       sin6_port;     // port number, Network Byte Order
    u_int32_t       sin6_flowinfo; // IPv6 flow information
    struct in6_addr sin6_addr;     // IPv6 address
    u_int32_t       sin6_scope_id; // Scope ID
};

struct in6_addr {
    unsigned char   s6_addr[16];   // IPv6 address
};

struct sockaddr_in sa; // IPv4
struct sockaddr_in6 sa6; // IPv6

inet_pton(AF_INET, "192.0.2.1", &(sa.sin_addr)); // IPv4
inet_pton(AF_INET6, "2001:db8:63b3:1::3490", &(sa6.sin6_addr)); // IPv6

// IPv4:

char ip4[INET_ADDRSTRLEN];  // space to hold the IPv4 string
struct sockaddr_in sa;      // pretend this is loaded with something

inet_ntop(AF_INET, &(sa.sin_addr), ip4, INET_ADDRSTRLEN);

printf("The IPv4 address is: %s\n", ip4);


// IPv6:

char ip6[INET6_ADDRSTRLEN]; // space to hold the IPv6 string
struct sockaddr_in6 sa6;    // pretend this is loaded with something

inet_ntop(AF_INET6, &(sa6.sin6_addr), ip6, INET6_ADDRSTRLEN);

printf("The address is: %s\n", ip6);

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>

int getaddrinfo(const char *node,     // e.g. "www.example.com" or IP
                const char *service,  // e.g. "http" or port number
                const struct addrinfo *hints,
                struct addrinfo **res);

int status;
struct addrinfo hints;
struct addrinfo *servinfo;  // will point to the results

memset(&hints, 0, sizeof hints); // make sure the struct is empty
hints.ai_family = AF_UNSPEC;     // don't care IPv4 or IPv6
hints.ai_socktype = SOCK_STREAM; // TCP stream sockets
hints.ai_flags = AI_PASSIVE;     // fill in my IP for me

if ((status = getaddrinfo(NULL, "3490", &hints, &servinfo)) != 0) {
    fprintf(stderr, "getaddrinfo error: %s\n", gai_strerror(status));
    exit(1);
}

// servinfo now points to a linked list of 1 or more struct addrinfos

// ... do everything until you don't need servinfo anymore ....

freeaddrinfo(servinfo); // free the linked-list

int status;
struct addrinfo hints;
struct addrinfo *servinfo;  // will point to the results

memset(&hints, 0, sizeof hints); // make sure the struct is empty
hints.ai_family = AF_UNSPEC;     // don't care IPv4 or IPv6
hints.ai_socktype = SOCK_STREAM; // TCP stream sockets

// get ready to connect
status = getaddrinfo("www.example.net", "3490", &hints, &servinfo);

// servinfo now points to a linked list of 1 or more struct addrinfos

// etc.

#include <sys/types.h>
#include <sys/socket.h>

int socket(int domain, int type, int protocol); 

int s;
struct addrinfo hints, *res;

// do the lookup
// [pretend we already filled out the "hints" struct]
getaddrinfo("www.example.com", "http", &hints, &res);

// [again, you should do error-checking on getaddrinfo(), and walk
// the "res" linked list looking for valid entries instead of just
// assuming the first one is good (like many of these examples do.)
// See the section on client/server for real examples.]

s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);

#include <sys/types.h>
#include <sys/socket.h>

int bind(int sockfd, struct sockaddr *my_addr, int addrlen);

struct addrinfo hints, *res;
int sockfd;

// first, load up address structs with getaddrinfo():

memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;  // use IPv4 or IPv6, whichever
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;     // fill in my IP for me

getaddrinfo(NULL, "3490", &hints, &res);

// make a socket:

sockfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);

// bind it to the port we passed in to getaddrinfo():

bind(sockfd, res->ai_addr, res->ai_addrlen)

int listen(int sockfd, int backlog); 

#include <sys/types.h>
#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); 

#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define MYPORT "3490"  // the port users will be connecting to
#define BACKLOG 10     // how many pending connections queue will hold

int main(void)
{
    struct sockaddr_storage their_addr;
    socklen_t addr_size;
    struct addrinfo hints, *res;
    int sockfd, new_fd;

    // !! don't forget your error checking for these calls !!

    // first, load up address structs with getaddrinfo():

    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;  // use IPv4 or IPv6, whichever
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = AI_PASSIVE;     // fill in my IP for me

    getaddrinfo(NULL, MYPORT, &hints, &res);

    // make a socket, bind it, and listen on it:

    sockfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
    bind(sockfd, res->ai_addr, res->ai_addrlen);
    listen(sockfd, BACKLOG);

    // now accept an incoming connection:

    addr_size = sizeof their_addr;
    new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &addr_size);

    // ready to communicate on socket descriptor new_fd!
    .
    .

#include <sys/types.h>
#include <sys/socket.h>

int connect(int sockfd, struct sockaddr *serv_addr, int addrlen); 

struct addrinfo hints, *res;
int sockfd;

// first, load up address structs with getaddrinfo():

memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;

getaddrinfo("www.example.com", "3490", &hints, &res);

// make a socket:

sockfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);

// connect!

connect(sockfd, res->ai_addr, res->ai_addrlen);

int send(int sockfd, const void *msg, int len, int flags); 

int recv(int sockfd, void *buf, int len, int flags);

int sendto(int sockfd, const void *msg, int len, unsigned int flags,
           const struct sockaddr *to, socklen_t tolen);

int recvfrom(int sockfd, void *buf, int len, unsigned int flags,
             struct sockaddr *from, int *fromlen); 

http://forum.falinux.com/zbxe/?document_srl=405838

이번 시간에는 시리얼 통신에서 자료를 수신하는 부분을 구현하려 합니다. 그러나 송신 보다 수신하는 부분은 생각할 점이 있습니다. 전송이야 이쪽에서 필요할 때 보내기만 하면 되기 때문에 “언제라는” 시간적인 문제가 없습니다. 그러나 수신은 자료가 언제 올지를 모르죠. 기다려야 한다는 것인데, 자료가 올 때까지 마냥 시리얼 포트만 쳐다 보고 있을 수 없습니다. 다른 일도 처리 해야죠. 해야할 일이 산더미처럼 쌓였는데, 마냥 포트만 쳐다 볼 수 없습니다. 

이럴 때 쉽게 생각할 수 있는 것이 일을 처리하는 중에 잠시잠시 포트를 확인하는 방법입니다. 가령 예를 들어서 아래와 같이 하는 것이죠.

while( 1)
{
  // 다른 업무를 실행
  if 0 < read( fd, buf, BUF_MAX_SIZE)
  {
    // 수신 자료를 처리
  }
}

물론 이와 같은 방법도 좋습니다만 ?자료 수신 이외의 이벤트 처리, 예로 통신에 에러가 발생하지 않았는지 등을 확인을 위해서는 또 다른 확인 루틴을 작성하고 if 절을 추가해야 합니다. 그러나 무엇보다도 read()함수가 block되 버리면 루틴 자체가 block되어 버리는 매우 큰 문제를 가지고 있습니다.

이럴 때 사용하는 것이 POLL입니다.

poll()

POLL은 확인하고 싶은 여러 가지 사건( 이하 event)를 미리 등록해 놓고 그 사건들이 발생했는지 확인할 수 있는 편리한 방법을 제공해 줍니다. POLL을 이용한 작업 진행 과정을 정리해 보면,

1. 체크하고 싶은 여러 event를 등록
2. poll() 함수를 호출하면
3. event가 발생하면 poll() 함수 호출 후에 바로 복귀하지만,
4. 발생된 event 가 없으면 하나 이상이 발생할 때 까지 time-out 시간 만큼 대기하게 됩니다.
5. event가 발생면 해당 event의 배열 아이템의 값이 변동이 되는데, 
   이 변동을 확인하여 어떤 event 가 발생했는지를 알 수 있습니다.

장황한 설명 보다는 먼저 간단한 예를 보여 드리고 그 후에 자세한 설명을 드리도록 하겠습니다. 예제는 이해를 돕기 위해 상수를 사용하지 않았고, 함수로 분리하지 않았습니다.

예제

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/poll.h>
#include <termios.h>                   // B115200, CS8 등 상수 정의
#include <fcntl.h>                     // O_RDWR , O_NOCTTY 등의 상수 정의

int main( void)
{        
   int    fd;
   int    ndx;
   int    cnt;
   char   buf[1024];
   struct termios    newtio;
   struct pollfd     poll_events;      // 체크할 event 정보를 갖는 struct
   int    poll_state;

   // 시리얼 포트를 open

   fd = open( "/dev/ttyS0", O_RDWR | O_NOCTTY | O_NONBLOCK );        // 디바이스를 open 한다.
   if ( 0 > fd)
   {        
      printf("open error\n");
      return -1;
   }

   // 시리얼 포트 통신 환경 설정

   memset( &newtio, 0, sizeof(newtio) );
   newtio.c_cflag       = B115200 | CS8 | CLOCAL | CREAD;
   newtio.c_oflag       = 0;
   newtio.c_lflag       = 0;
   newtio.c_cc[VTIME]   = 0;
   newtio.c_cc[VMIN]    = 1;
   
   tcflush  (fd, TCIFLUSH );
   tcsetattr(fd, TCSANOW, &newtio );
   fcntl(fd, F_SETFL, FNDELAY); 


   // poll 사용을 위한 준비
   
   poll_events.fd        = fd;
   poll_events.events    = POLLIN | POLLERR;          // 수신된 자료가 있는지, 에러가 있는지
   poll_events.revents   = 0;


   // 자료 송수신

   while ( 1)
   {
      poll_state = poll(                               // poll()을 호출하여 event 발생 여부 확인     
                         (struct pollfd*)&poll_events, // event 등록 변수
                                                   1,  // 체크할 pollfd 개수
                                                1000   // time out 시간
                       );

      if ( 0 < poll_state)                             // 발생한 event 가 있음
      {     
         if ( poll_events.revents & POLLIN)            // event 가 자료 수신?
         {
            cnt = read( fd, buf, 1024);
            write( fd, buf, cnt);
            printf( "data received - %d %s\n", cnt, buf);
         }
         if ( poll_events.revents & POLLERR)      // event 가 에러?
         {
            printf( "통신 라인에 에러가 발생, 프로그램 종료");
            break;
         }
      }
   }
   close( fd);
   return 0;
}

  예제를 보시면 struct pollfd를 사용했습니다. struct pollfd의 내용을 보면 아래와 같습니다.

struct pollfd 
{
  int fd;             // 대상 파일 디스크립터 
  short events;   // 발생된 이벤트 
  short revents;   // 돌려받은 이벤트 
};

1. fd는 감시 대상인 디스크립터, 즉 핸들이 되겠습니다.
2. events는 체크하고 싶은 event의 모음입니다. 여기서 체크가 가능한 것은 아래와 같습니다.

• #define POLLIN 0x0001 // 읽을 데이터가 있다.
• #define POLLPRI 0x0002 // 긴급한 읽을 데이타가 있다.
• #define POLLOUT 0x0004 // 쓰기가 봉쇄(block)가 아니다.
• #define POLLERR 0x0008 // 에러발생
• #define POLLHUP 0x0010 // 연결이 끊겼음
• #define POLLNVAL 0x0020 // 파일지시자가 열리지 않은 것 같은, Invalid request (잘못된 요청)

3. revents 는 event 발생 여부를 bit 별로 갖는 값입니다.

  자, 이제 예제를 보겠습니다.

struct pollfd poll_events; // 체크할 event 정보를 갖는 struct

poll()을 사용하기 위한 변수를 선언했습니다. poll_events 에는 감시 대상인 디스크립터와 어떤 event를 감시할지 결정해서 bit 값으로 지정해 줄 것입니다. 

int poll_state;

poll()이 수행한 결과값을 갖습니다. 이 값은 반드시 체크해야 하는데, 아래와 같은 반환값을 갖습니다.

 

poll() 수행 후 반환 값
반환 값	설명
음수	반환 값이 음수라면 치명적인 에러가 발생한 것입니다. 한번 이렇게 음수로 에러가 발생하면 이후 계속 음수값이 날라 옵니다. 거의 대부분 프로그램을 다시 실행해야 됩니다. 반드시 체크해야 겠지요.
0	지정한 대기시간, time-out이 지나도록 발생한 event가 없습니다.
양수	event 가 발생했습니다.

poll_events.fd = fd;

감시 대상인 디스크립터를 지정합니다.

poll_events.events = POLLIN | POLLERR; // 수신된 자료가 있는지, 에러가 있는지

체크하고 싶은 event에 대해 비트값으로 설정하여 지정해 줍니다.

poll_events.revents = 0;

revents를 0 으로 청소해 주고요.

poll_state = poll(                               // poll()을 호출하여 event 발생 여부 확인     
                  (struct pollfd*)&poll_events, // event 등록 변수
                                             1,  // 체크할 pollfd 개수
                                          1000   // time out 시간
                );

체크할 event 정보를 넘겨 줍니다. 1은 체크할 pollfd 개수입니다. 이 예제를 가지고는 pollfd의 개수가 왜 필요한지 이해가 안되시죠. 예제에는 감시하는 디스크립터가 한 개이지만 프로그램에 따라서는 한번에 여러 개의 디스크립터를 관리할 경우가 많습니다.

 

관리할 디스크립터가 많을 때, 각각을 변수로 처리하는 것 보다 배열로 처리하는 것이 편하겠죠. 이래서 poll() 이 편리합니다. poll()은 변수 하나 외에도 배열을 받을 수 있으며, 한번의 호출로 모든 event 발생 여부를 확인할 수 있어 매우 편리합니다.

 

참고 앞으로 강좌를 진행하면서 말씀 드리겠습니다만 poll()을 사용하는 또 다른 장점은 서로 다른 특징의 디스크립터를 사용한다 해도 프로그램 코드를 통일할 수 있습니다. 예로 rs232c 포트 10개와 tcp/ip 소켓 10개를 한번에 제어하는 프로그램을 작성했을 경우 역시 하나의 배열로 구성해서 poll()을 사용할 수 있기 때문에 rs232c 처리와 tcp/ip 처리하는 프로그램 코드를 통일할 수 있습니다.

 

1000은 time-out 시간으로 발생한 event 가 없을 경우 poll()은 event가 발생할 때 까지 time-out 시간 동안 대기하게 됩니다.

이 시간 값은 msec로 1000은 1초를 의미합니다. 0 이면? 바로 복귀합니다. -1 이면? evevnt 가 발생할 때 까지 기다리게 됩니다. 즉, block되 버리죠.

if ( 0 < poll_state)

poll() 함수 결과가 양수라면 event 가 발생한 것입니다.

if ( poll_events.revents & POLLIN)

발생한 event 중에 POLLIN 이 있는 지를 확인합니다. POLLIN에 해당되는 bit 가 1로 세트되어 있다면 POLLIN으로 AND한 값은 0 이 아닐 것입니다. 이렇게 비트값을 확인하여 event 발생 여부를 확인할 수 있습니다.

cnt = read( fd, buf, 1024);
write( fd, buf, cnt);
printf( "data received - %d %s\n", cnt, buf);

자료 수신 event 가 발생했으므로 fd로부터 자료 값을 읽어 들이고, 예제 테스트를 위해 다시 그 자료를 전송합니다. 또한 화면에도 수신한 자료를 뿌리고 있죠.

이번에는 IPC 기법 중 PIPE 에 대하여 알아보도록 하겠습니다.

파이프의 느낌은 슈퍼마리오의 게임에서 파이프를 타고 입구와 출구를 오가는 그런 느낌이죠.

IPC 에서 PIPE 를 간단하게 설명한다면, 

여러개의 프로세스가 공통으로 사용하는 임시공간이라고 할 수 있습니다.

그리고 그 임시 공간은 실제로 파일 시스템에 생성되는 임시 파일입니다.

하나의 프로세스가 파이프에 쓰게 되면 다른 프로세스는 그 파이프에서 읽는 방식으로 쓰게 됩니다.

위에 그림처럼 파이프는 시스템 내부에서 관리하는 임시 파일을 이용하므로, 

다른 IPC 기법 중 하나인 SIGNAL 과는 다르게 대용량의 메시지도 전송이 가능합니다.

이런 파이프는 보통 익명의 파이프와 이름을 가진 Named Pipe 의 두가지 방법으로

사용할 수 있도록 OS 가 제공 합니다.

파이프는 소켓 등의 비하면 꽤 단순한 IPC 기법으로 여러가지 특징을 가지고 있습니다.

그중 첫번째 특성은, 파이프는 입구와 출구의 개념이 없다는 것입니다.

파이프는 단순한 통로 입니다. 

방향성이 없기 때문에 자신이 쓴 메시지를 자신이 읽을 수 있다는 것을 항상 유의해야 합니다.

그렇기 때문에 두개의 프로세스가 통신할 때는 

읽기전용 파이프와 쓰기 전용 파이프의 두 개의 파이프를 쓰게 됩니다.

두개의 파이프를 생성하고, 한쪽 파이프를 일부러 닫아 버리는 것이지요.

그래서 결국은 아래 그림처럼 파이프를 두개 생성하여 하나의 방향으로만 갈 수 있도록 합니다.

또 파이프의 특성 중 유의할 것은 파이프는 fork() 함수에 의해 복사 되지 않는다는 것입니다.

fork() 함수에 의해서 프로세스가 생성되면, 자식 프로세스는 부모가 사용하던 변수를 복사하게 됩니다.

하지만 파이프의 경우 복사되는것이 아니라 File Descriptor 를 공유하게 됩니다.

즉 자식 프로세스와 부모 프로세스가 같은 파이프를 가리키게 됩니다.

그외에도 익명의 파이프는 또 하나의 주요한 특성이 있습니다.

부모 자식프로세스 사이에서만 파이프를 사용 가능하다는 것입니다.

파이프는 운영체제에서 임시로 생성되는 파일이고, 접근 가능한 방법은

File Descriptor(파일 디스크립터) 를 공유하는 방법만이 존재합니다.

익명의 파이프는 부모와 자식 프로세스만이 파일 디스크립터를 공유하므로

다른 프로세스는 파이프를 사용하여 통신이 불가능 합니다.

반면 Named PIPE(네임드 파이프) 의 경우 다른 프로세스도,

지정한 이름으로 파일 디스크립터를 열수 있기 때문에,

부모 자식 프로세스 간이 아니더라도 사용할수 가 있는 것이죠.

출처:
 
http://akj61300.blog.me/80133137262 

FIFO

#include <sys/types.h> 
#include <sys/stat.h> 

int main(int argc, char **argv)
{
    if (mkfifo(argv[1], 0666) != 0)
    {
        perror("mkfifo failure : ");
    }

    return 0;
}

[root@localhost test]# ./fifo /tmp/testfifo2
[root@localhost test]# ls -al /tmp/testfifo2
prw-r--r--    1 root     root            0  2월  7 16:26 /tmp/testfifo2

#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <stdio.h> 
#include <unistd.h> 

int main()
{
    FILE *fp;

    char buf[255];
    if((fp = fopen("/tmp/testfifo", "rw")) == NULL)
    {
        perror("open error : ");
        exit(0);
    }


    memset(buf, 0x00, 255);
    while(1)
    {
        while(fgets(buf, 255, fp) != NULL)
        {
            printf("%s", buf);
            memset(buf, 0x00, 255);
        }
    }
}

[yundream@localhost /tmp]# echo "hello world" > testfifo

#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <stdio.h> 
#include <unistd.h> 

#define chop(x) x[strlen(x) - 1] = 0x00 

int main()
{
    int fp_w;
    int fp_r;

    int n;
    char buf_r[11];
    char buf_w[11];
    if((fp_r = open("/tmp/fifo_c", O_RDONLY)) < 0)
    {
        perror("open error : ");
        exit(0);
    }
    if((fp_w = open("/tmp/fifo_s", O_WRONLY)) < 0)
    {
        perror("open error : ");
        exit(0);
    }


    memset(buf_r, 0x00, 11);
    memset(buf_w, 0x00, 11);

    while((n = read(fp_r, buf_r, 11)) > 0)
    {
        printf("%s", buf_r);
        chop(buf_r);
        sprintf(buf_w, "%d\n", atoi(buf_r) * atoi(buf_r));

        write(fp_w, buf_w, 11);

        memset(buf_r, 0x00, 11);
        memset(buf_w, 0x00, 11);
    }
    exit(1);
}

#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <stdio.h> 
#include <unistd.h> 

#define chop(x) x[strlen(x) - 1] = 0x00 

int main()
{
    int fp_r;
    int fp_w;
    int n;
    int i;
    char buf_r[11];
    char buf_w[11];

    if((fp_w = open("/tmp/fifo_c", O_WRONLY)) < 0)
    {
        perror("open error : ");
        exit(0);
    }
    if((fp_r = open("/tmp/fifo_s", O_RDONLY)) < 0)
    {
        perror("open error : ");
        exit(0);
    }


    i = 1;

    memset(buf_r, 0x00, 11);
    memset(buf_w, 0x00, 11);
    sprintf(buf_w, "%d\n", i);

    while((n = write(fp_w, buf_w, 11)) > 0)
    {
        read(fp_r, buf_r, 11);

        printf("%6d^2 = %s", atoi(buf_w), buf_r);
        memset(buf_r, 0x00, 11);
        memset(buf_w, 0x00, 11);
        i++;
        sprintf(buf_w, "%d\n", i);
        sleep(1);
    }
}

[yundream@localhost test]#./fifo_s
1
2
3
4
5
6
7
8
9
10
11

[yundream@localhost test]#./fifo_c
     1^2 = 1
     2^2 = 4
     3^2 = 9
     4^2 = 16
     5^2 = 25
     6^2 = 36
     7^2 = 49
     8^2 = 64
     9^2 = 81
    10^2 = 100
    11^2 = 121
...

링킹 과정은 컴파일과 링킹에서 마지막 과정으로 조각난 오브젝트 파일들을 하나의 바이너리 이미지로 합치는 과정

|| 링킹과정 절차

$ gcc -o test main.c funcs.c -v -save-temps

출처:

http://www.oneone.kr/?mid=UnixPUtil&page=1&document_srl=5700

 

|| 가장 단순한 컴파일 명령

gcc -W -Wall -O2 -o like like.c

|| 반드시 알아야 할 gcc 필수 옵션 및 중요 옵션

1) gcc C컴파일러 드라이버 옵션

-E : 전처리 과저의 결과를 화면에 보이는 옵션, 추가적으로 -save-temps 옵션을 사용해 like.i 파일을 읽어보는 것이 더 좋은 방법

-S : 어셈블리 파일만 생성하고 컴파일 과정을 멈춘다.

-c : 오브젝트 파일까지만 생성하고 컴파일 과정을 멈춘다.

-v : 과정 보여주기

-save-temps : 컴파일과정에서 생성되는 *.i, *.s, *.o 지우지 않고 저장한다.

2) cc1 -E 또는 cpp0 전처리기 옵션

- I : 헤더파일을 탐색하는 기본디렉토리를 추가할 때

-D : 매크로를 외부에서 define할 때 사용, 반대는 -U[매크로]

3) cc1 C 컴파일러의 옵션

* 경고 옵션

-W과 -Wall : Wall옵션은 모든 모호한 문법에 대한 경고메시지 출력, -W는 합법적이지만 모호한 코딩에 대한 부가적인 정보제공

-w : 모든 경고메시지 제거

* 최적화 옵션

-O0

-O1

-O2

-O3

-Os : 사이즈 최적화, 임베디드 시스템 같은데 사용

* 디버깅 옵션

-g : 디버거에 제공하는 디버깅 정보를 바이너리에 삽입한다.

 최적화옵션처럼 레벨이 있는데 -g0 ~g3, 기본은 g2와 동일

4) as의 옵션

생략

5) collect2 또는 ld의 옵션

-L[라이브버리 디렉토리] : 라이브러리를 찾을 디렉토리를 지정한다.

-[라이브버리 이름] : 라이브러리의 이름은 앞에 오는 lib를 떼어버리고 확장자 이전까지의 라이브러리명이다.

-shared : 공유 라이브러리를 우선 링크, 디폴트는 공유 라이브러리

-static : 정적 라이브러리 우선링크

2) cc1 중단부에서 하는 일

 중단부에서 하는 일은 GIMPLE트리를 입력받아 SSA형태로 변환한 후 SSA에 기초한 아키텍쳐 비종속적인 최적화를 수행하고, 최종적으로 cc1후단부에서 사용할 RTL을 생성하는 일이다.

 -아키텍쳐 비종속적 : 아키텍쳐에 구애 받지 않는 최적화

* SSA 변환

i = 10

j = i + 10

k = j + 20 

이를 SSA로 변경하면

i_1 = 10

j_2 = i_1 + 10

k_3 = j_2 + 20

이처럼 된다.

컴파일시 -fdump-tree-all -O3 옵션을 지정하고 컴파일하면 ssa파일이 생성된다.

* RTL 생성

RTL은 GCC에서 기계 독립적인 특성을 제공하기 위해 사용하는 중간표현의 한 형태다.

[testone@oneone study]$ gcc -o CTest CTest.c -da