㈠ 程序员的自我修养最新版是哪年的
本书主要介绍系统软件的运行机制和原理，涉及在Windows和Linux两个系统平台上，一个应用程序在编译、链接和运行时刻所发生的各种事项，包括：代码指令是如何保存的，库文件如何与应用程序代码静态链接，应用程序如何被装载到内存中并开始运行，
㈡ 对于程序员的自我修养这本书，你怎么看
还不错的一本书，主要讲了装载，链接，库，三个方面，是程序员调试程序，了解程序运行原理不可多得的一本好书，推荐！！！
㈢ 一个程序员所必须学习的有哪些，以及自我修养是什么
一个优秀的程序员必须不断学习的课程：
1、专业的的理论教程，系统的知识学习面。
要成为一名出色的程序员，从数据结构、算法。数据库都需要系统全面的了解和认识，并可以灵活运用。对自己所从事的编程语言要灵活调用。
2、不断尝试，乐于挑战。
编程高手都是从不断的失败和尝试中走出来的，所以对于一个刚入门的新手来说，任务就是不断的去编程，发现自身存在的缺陷，以及更熟练的掌握各种数据接口的调试和数据调用的应用。
3、好学，不耻下问。
成功都是建立在无数次尝试的基础上的，同时也需要利用前辈们已经得出的一些规律，尽量的少走弯路。
4、保持良好的心态。
编程每天对着的都是一些枯燥的单词以及数据，所以保持一个良好的心态是至关重要的，只有拥有一个良好的心态，才是端正自己学习和勤奋的根本。
5、善于从生活中发现需求。
每一个程序都是为了满足网名的一种需求，所以发现网名的的需求，并把这种需求利用程序解决，可以极大的促进自己的职业发展。
6、扩大自己的视野。
编程的同时，我们也要紧跟时代的步伐，学习更多的前进的经验以及技术，更好的为自己所用。
㈣ 一个程序员需要有怎样的自我修养
作为一名程序员，一个“程序员的自我修养”是什么？
尽管我们不一定要像尹天仇那么的认真对待自己的事业，但，一些基本的修养，作为一名新时代的码农，总应该是要具备的吧。不过真要说修养，方面还是挺多的，技术自我提示自不必说。但我并不打算从这个大家都觉得理所当然的技术方面入手，而是谈谈，可读性代码，这个容易被大家忽视的基本素养。
1、遵从所在团队的代码规范。
一个高效、成熟的团队，必定有一个属于自己的代码规范，这个规范是团队的宝贵的财富，它是整个团队从各种坑中爬起来后积累的经验教训。什么是规范，它是人们从无数经验中总结出来的规则，标准。而代码规范，指导团队成员如何以最短的时间写成最高效，可读性强的代码。试想，如果成员不遵从规范，你用驼峰命名，他用下划线，这对程序的可读，将造成多大的影响。我想，应该没有一个人愿意去阅读一段，各种变量命名形式都能见得到，private, public 方法随意排序，甚至常量类都散落在各个角落的代码吧。
代码，一个作用是让机器阅读，另一个重要的作用是让人阅读！！！
2、遵从行业内通用的规范
在团队的代码规范未涉及到的，那请按照行业内的规范来编写代码。规范的一个好处是，可以明显减少学习和交流成本。在java中，当我们看到全大写的变量名时，我们就知道这是常量，而不需要去看注释，不需要去看代码逻辑。为什么这么迅速，因为行业里大家都习惯把常量用大写命名。但假如你用其他命名方式命名常量，比如team_nums命名常量，不仅不能让人迅速知道这是个常量，而且可能让人误会这是个变量，增加了团队成员学习和沟通成本，甚至可能误导他们。就见过一位仁兄，明明用的是工厂模式，偏偏按模版模式的命名方式来命名，问他，他说他知道这是工厂模式，但他觉得，更应该叫模版模式。。。我的天，，你这么任性，以后还能做朋友么?
举个例子，我们需要根据支付类型，来生产多个支付产品，于是，我们写了个工厂类，命名为FactoryPay。当其他人看到一个类叫FactoryPay，他们会猜测，这应该是个工厂类，负责生产各种支付产品的工厂，然后按照这个猜测去阅读代码，就能比较快速的理解整个类的作用。但是，假如我取名PowerPay，别人还不知道是啥，看了半天，才明白，这是个工厂的作用。这就明显增加了他人的学习成本和维护代码的成本。
不管你是新手还是老鸟，务必了解施行行业规范，切勿为了标新立异而违反规范。这么低端的装逼，就没必要采用了，要装也写个高端的框架来提升逼格呗。
3、变量、方法命名要能表达变量作用
在程序员这个圈子很久了，就发现，程序员这货，都喜欢这套，“这个接口干嘛用的，有文档么”，“自己看代码去”。很多时候都是一脸黑。
尽管程序员阅读别人代码技术都是一流，不管你是有没有注释，不管你是怎么循环嵌套，也不管你是怎么命名，他们都能耐心的，把代码分析个所以然来。但，对于程序员这个视时间宝贵如生命，分分钟都能创造几百万价值的群体来说，您行行好，给我们省点时间吧，把变量是干啥用的，说清楚呗，没准节省的这几分钟，多赚个几万，还能请大家出去嗨呢。
每每看到部门的某大神，用一个神一般的变量名“flag”，我就有吐血的冲动，他还这个flag一直雪藏，不用，只是传递到第n个方法才使用，顿时心力交瘁，我的天，这个flag都是是干嘛用的啊，后来才明白，是isPay的意思，用来标识用户是否支付成功了。当时一口老血吐屏幕上，心里狂吐槽，老兄，你命名个isPay会死么，我的脑细胞这么不值钱么。到后来看到，去魔法数字，用int NUM_7 = 7,而不是MAX_MEMBERS来表示最大成员、用x y z来命名变量名，各种只有作者，或者作者后来都忘了的独特命名方式，都见怪不怪了。更有甚者，一个变量命名为passed，作用居然是“未通过”的意思，当时就石化了，作者还真是用心良苦，这都要考我细心不细心。
一个好的变量名，能帮助阅读者了解变量的作用，也辅助了对整段代码的理解。
4、不要show英语，乡下的孩子伤不起唉
LZ所在的团队，英语一直都是团队的硬伤，但总是能看到，某位仁兄，加上大把大把的英文注释，有些变量名也取些高大上的复杂的英语单词。敢问，你这么高的逼格，以后我们怎么和你玩啊。(那位仁兄其实就是LZ，年轻时唉，罪过罪过)
代码是用来沟通的，传递作者意图的，都看不懂，怎么沟通交流。建议英语好的童鞋，英语能力可以放到阅读英文书籍中展示，在代码中，如果团队英语能力很弱，避免使用英文，变量命名也尽量按照团队英语水平来命名
5、添加必要的注释
正如上面LZ说的，经常遭遇“你仔细看看代码，就知道干嘛用的”这样的神回复。尽管阅读代码是每个程序员的强项，但必要的注释，比如逻辑比较复杂的地方，添加必要的注释，对提升团队成员阅读熟悉代码的效率是有很大帮助的。试想，一个类，几百行，没有一行注释，对于阅读者来说，阅读它将是一个多么恐怖的事。
6、注释保持简洁，避免没有必要的注释
即看过一行注释都没有的代码，也看过注释比代码还要多的程序。一个是让人生不如死，一个是让人痛不欲生。(唉，有时不仅感叹，在程序员界混，真的是难)。
LZ就经常看过，一大段注释，啰嗦了半天，要不就是没表达清楚重点，要不就是只为说明它是个循环的作用！！！譬如i++这样的代码，有必要加个“每个计数增加1”这样的注释么，这完全是把读者定位为非程序员啊，或者就是严重鄙视读者的编程水平。
注释是帮助阅读的人更好的理解程序的逻辑，只是辅助，如果不重视通过命名等方式来传递代码的作用，而是依赖于注释，这就是本末倒置了。而且，冗长啰嗦的注释，这到底是帮助人理解，还是阻碍人理解啊，是读程序还是读小说啊。
7、拥有自己的编码规范
规范是为了让团队更快的理解、熟悉代码的，同理，拥有自己的一套规范，就能帮助其他人更快的理解我们所写的功能，减少学习和沟通成本。
8、代码清晰简洁的表达出作者的意思
在我们每次写完一段代码时，一定要问问自己，代码是否表达清楚了我的意思，是否需要添加些注释，名字取得是否恰当了，别人在阅读时是否吃力。。每每看到别人一团糟的费解的代码，就时刻提醒自己，一定要把代码写好咯，我也确实是这么做的，一遍又一编的检查，看变量名、方法名是否表明了它的用途，是否有些不必要的、只是为了提升逼格的代码，别人是否能在短时间内看懂。所有的这些，只是为了写出一段更优美的代码。
9、坚持并捍卫上面的准则
经常能听到，有些公司是代码行数来定义绩效的，但作为一个有操守，并秉承基本自我修养的程序员，我们绝不能为了各种诱惑或者胁迫，甚至是自己的惰性、个性，而放弃写出简洁清晰，可读的代码。
以上的几点，并不是严格的意见或者建议，只是提醒广大程序员同胞们，在痴心与高端的技术时，千万不要忘了，代码不仅机器要阅读，人也需要阅读。就算你写出再复杂的代码，但它让人完全无法阅读，这有什么用呢。这就如同，你很牛逼很牛逼，但别人听不懂你说的话，还不是没用。如果你真的写出了可读性强的代码，但你也不应该鸣鸣得意，我觉得，写出一段优美，健壮，可读性高的代码，是一个程序员最基本的自我修养。
㈤ 程序员的自我修养这本书 是清华大学出版社的 还是电子工业
程序员作为一个职业、也作为一个群体，正逐渐从幕后走向前台，并以他们自己的能力加速改变着世界，也改变着人们生活的方方面面。然而，对于程序员，特别是年轻程序员们来说，如何理解自己的职业与发展，如何看待自己的工作与生活，这些问题往往比那些摆在面前的技术难题更让他们难以解答。这本书从一个成熟程序员、一名IT管理者的角度，以杂记的形式为大家分享关于国内程序员职业生涯、个人发展、编程中的实践与认知乃至自学设计等方面的经验方法与思考感悟。其中每一篇文章都涉及一个与程序员息息相关的话题，无论你是即将走上程序员岗位的在校大学生，是刚刚成为程序员的职场新人，还是有一定经验的程序员，这本书都会给你带来启发。
㈥ 作为一个程序员，有哪些职业自我修养呢
保持对代码的热情，持续学习
从现实工作的角度考虑，这可能不是最重要的一条，毕竟持续学习这类话，已经老生常谈到快厌烦的地步了。比起学习，可能在每个写过的类里面加上你的注释，甚至包括姓名还有联系方法更实用些。但我想说的是，保持对本行业持续热情，并不断学习，应该是每个从业者最基本的素养，而对于程序员来讲，就是保持对代码的热情。
当然，这里的保持热情、不断学习，并不是一句空话，而是要真正做到的。从长远角度讲，只有不断提升自己的专业技能，才能更好的应付将来对本职工作提出的新的要求。同时，对于自己来讲，也只有不断学习，才能让自己时刻保持出色的竞争力。
养成良好的工作习惯
从编程本身来讲，尽量写出逻辑严密的代码，多写注释，少留bug，不要给后人挖坑，经常做代码评审（code review）和代码重构（code refactoring）。一个好的编程习惯可以提高效率、减少重复工作等等。从职场沟通角度来讲，养成即时反馈，定时汇报的工作习惯，可以避免因为沟通不畅导致多走许多弯路。
因此，对于一个程序员来讲，养成一个良好的工作习惯，也因该是作为一个程序员的基本自我职业修养。（高中上完想学电脑编程,电脑编程培训多少钱）
及时调整心态的能力
大多数程序员的工作，都是项目制的。在项目期间，996甚至007都是常态，因此可能会有比较大的压力。同时，在项目实施过程中，遇到挫折也要及时调整心态重整旗鼓。所以，作为一名码农，也要有及时调整心态的能力。
㈦ 求t《tcp/ip详解》《软件测试的艺术》 《程序员自我修养--》电子书
《软件测试的艺术》中文版清晰.pdf免费下载
链接:https://pan..com/s/1GYbyq1bSXiM4F2V9ezrVgA
《软件测试的艺术》（原书第3版）是2012年机械工业出版社出版的图书。本书展示了各类软件测试的方法和智慧，阐述了如何将经典软件测试法则应用到解决当今计算机行业所面临的问题之中。
㈧ 程序员的自我修养: fread-C语言是怎样读取文件的
为了效率的考虑,不至于频繁调用系统函数和访问IO设备,MSVC CRT的fread采用缓冲设计. C语言提供的关于缓冲的函数有:int flush(FILE* stream); int setvbuf(FILE* stream, char* buf, int mode, size_t size); /* 缓冲模式mode有: 1. 无缓冲模式 _IONBF 2. 行缓冲模式 _IOLBF 每收到一个换行符(/n或/r/n), 就将缓冲flush掉 3. 全缓冲模式 _IOFBF 仅当缓冲满时才进行flush */ void setbuf(FILE* stream, char* buf); 等价于 (void)setvbuf(stream, buf, _IOBBF, BUFSIZ); fread的调用过程大概是:fread -> fread_s(增加缓冲溢出保护, 加锁) -> _fread_nolock_s(循环读取,缓冲) -> _read(换行符转换) -> ReadFile(读取文件) 加注释的FILE结构如下:struct _iobuf { char *_ptr; int _cnt; //剩余未读的字节数 char *_base; //文件的缓冲基址 int _flag; //打开文件的属性 int _file; //打开文件的编号 int _charbuf; int _bufsiz; //文件的缓冲的总的大小 char *_tmpfname; }; typedef struct _iobuf FILE; 核心函数_fread_nolock_s(循环读取,缓冲)如下:size_t __cdecl _fread_nolock_s( void *buffer, size_t bufferSize, size_t elementSize, size_t num, FILE *stream ) { char *data; /* point inside the destination buffer to where we need to the read chars */当前放进字节的尾部 size_t dataSize; /* space left in the destionation buffer (in bytes) //buffer中剩余字节数*/ size_t total; /* total bytes to read //总共要读的字节数*/ size_t count; /* num bytes left to read //剩下要读的字节数*/ unsigned streambufsize; /* size of stream buffer */ unsigned nbytes; /* how much to read now */ unsigned nread; /* how much we did read */ int c; /* a temp char */ /* initialize local vars */ data = buffer; dataSize = bufferSize; if (elementSize == 0 || num == 0) { return 0; } /* validation */ _VALIDATE_RETURN((buffer != NULL), EINVAL, 0); if (stream == NULL || num > (SIZE_MAX / elementSize)) { if (bufferSize != SIZE_MAX) { memset(buffer, _BUFFER_FILL_PATTERN, bufferSize); } _VALIDATE_RETURN((stream != NULL), EINVAL, 0); _VALIDATE_RETURN(num <= (SIZE_MAX / elementSize), EINVAL, 0); } count = total = elementSize * num; if (anybuf(stream)) { /* already has buffer, use its size */ streambufsize = stream->_bufsiz; } else { /* assume will get _INTERNAL_BUFSIZ buffer */ streambufsize = _INTERNAL_BUFSIZ; } /* here is the main loop -- we go through here until we're done */ while (count != 0) { /* if the buffer exists and has characters, them to user buffer */ if (anybuf(stream) && stream->_cnt != 0) { if(stream->_cnt < 0) { _ASSERTE(("Inconsistent Stream Count. Flush between consecutive read and write", stream->_cnt >= 0)); stream->_flag |= _IOERR; return (total - count) / elementSize; } /* how much do we want? (unsigned)count : stream->_cnt; if (nbytes > dataSize) { if (bufferSize != SIZE_MAX) { memset(buffer, _BUFFER_FILL_PATTERN, bufferSize); } _VALIDATE_RETURN(("buffer too small", 0), ERANGE, 0) } memcpy_s(data, dataSize, stream->_ptr, nbytes); /* update stream and amt of data read */ count -= nbytes; stream->_cnt -= nbytes; stream->_ptr += nbytes; data += nbytes; dataSize -= nbytes; } else if (count >= streambufsize) { /* If we have more than streambufsize chars to read, get data by calling read with an integral number of bufsiz blocks. Note that if the stream is text mode, read will return less chars than we ordered. */ if (streambufsize) { /* In 64bit apps size_t is bigger than unsigned * (which is 32bit even in 64 bit machines), so * we need to split the read into INT_MAX chunks * since _read() only support up to _signed_ int * (even though the in parameter is unsigned). */ if (count > INT_MAX) { /* calc chars to read -- the largest multiple of streambufsize * smaller then INT_MAX */ nbytes = (unsigned)(INT_MAX - INT_MAX % streambufsize); } else { /* calc chars to read -- (count/streambufsize) * streambufsize */ nbytes = (unsigned)(count - count % streambufsize); } } else { nbytes = (count > INT_MAX)?(unsigned)INT_MAX: (unsigned)count; } if (nbytes > dataSize) { if (bufferSize != SIZE_MAX) { memset(buffer, _BUFFER_FILL_PATTERN, bufferSize); } _VALIDATE_RETURN(("buffer too small", 0), ERANGE, 0) } nread = _read(_fileno(stream), data, nbytes); if (nread == 0) { /* end of file -- out of here */ stream->_flag |= _IOEOF; return (total - count) / elementSize; } else if (nread == (unsigned)-1) { /* error -- out of here */ stream->_flag |= _IOERR; return (total - count) / elementSize; } /* update count and data to reflect read */ count -= nread; data += nread; dataSize -= nread; } else { /* less than streambufsize chars to read, so call _filbuf to fill buffer */ if ((c = _filbuf(stream)) == EOF) { /* error or eof, stream flags set by _filbuf */ return (total - count) / elementSize; } /* _filbuf returned a char -- store it */ if (dataSize == 0) { if (bufferSize != SIZE_MAX) { memset(buffer, _BUFFER_FILL_PATTERN, bufferSize); } _VALIDATE_RETURN(("buffer too small", 0), ERANGE, 0) } *data++ = (char) c; --count; --dataSize; /* update buffer size */ streambufsize = stream->_bufsiz; } } /* we finished successfully, so just return num */ return num; } 其中,int __cdecl _filwbuf ( FILE *str ) #endif /* _UNICODE */ { REG1 FILE *stream=NULL; /* In safecrt, we assume we always have a buffer */ _VALIDATE_RETURN(str != NULL, EINVAL, _TEOF); /* Init pointer to _iob2 entry. */ stream = str; if (!inuse(stream) || stream->_flag & _IOSTRG) return(_TEOF); if (stream->_flag & _IOWRT) { stream->_flag |= _IOERR; return(_TEOF); } stream->_flag |= _IOREAD; /* Get a buffer, if necessary. */ if (!anybuf(stream)) { #ifndef _SAFECRT_IMPL _getbuf(stream); #else /* _SAFECRT_IMPL */ /* In safecrt, we assume we always have a buffer */ _VALIDATE_RETURN(FALSE, EINVAL, _TEOF); #endif /* _SAFECRT_IMPL */ } else { stream->_ptr = stream->_base; } stream->_cnt = _read(_fileno(stream), stream->_base, stream->_bufsiz); #ifndef _UNICODE if ((stream->_cnt == 0) || (stream->_cnt == -1)) { #else /* _UNICODE */ if ((stream->_cnt == 0) || (stream->_cnt == 1) || stream->_cnt == -1) { #endif /* _UNICODE */ stream->_flag |= stream->_cnt ? _IOERR : _IOEOF; stream->_cnt = 0; return(_TEOF); } if ( !(stream->_flag & (_IOWRT|_IORW)) && ((_osfile_safe(_fileno(stream)) & (FTEXT|FEOFLAG)) == (FTEXT|FEOFLAG)) ) stream->_flag |= _IOCTRLZ; /* Check for small _bufsiz (_SMALL_BUFSIZ). If it is small and if it is our buffer, then this must be the first _filbuf after an fseek on a read-access-only stream. Restore _bufsiz to its larger value (_INTERNAL_BUFSIZ) so that the next _filbuf call, if one is made, will fill the whole buffer. */ if ( (stream->_bufsiz == _SMALL_BUFSIZ) && (stream->_flag & _IOMYBUF) && !(stream->_flag & _IOSETVBUF) ) { stream->_bufsiz = _INTERNAL_BUFSIZ; } #ifndef _UNICODE stream->_cnt--; return(0xff & *stream->_ptr++); #else /* _UNICODE */ stream->_cnt -= sizeof(wchar_t); return (0xffff & *((wchar_t *)(stream->_ptr))++); #endif /* _UNICODE */ } 代码中分了三种情况:1) 缓冲区不为空此时, 把缓冲区中的数据复制到传入的字符数组中. 2) 缓冲区为空, 需要读取的数据大于缓冲的尺寸此时, 直接调用函数_fread把文件中的内容写到传入的字符数组中. 3) 缓冲区为空, 需要读取的数据不大于缓冲的尺寸此时, 调用函数_fread读满缓冲区, 并再写缓冲区的一个字符到传入的字符数组中. 若未读满传入的字符数组, 循环执行上述1~3过程, 直到读满或读到文件末尾(EOF).
㈨ C文件如何成为可执行文件（编译、链接、执行）——摘自《程序员的自我修养》
本文算是我阅读《程序员的自我修养》（俞甲子等着）相关章节的笔记，文中直接引用了原书中的叙述，强烈建议大家去看原书，本文只做概要介绍而用。——注：文中有很多引用图的地方，请大家自己去找原书看，支持正版！我遇到一个问题，Linux C编程中的问题：.. char *p; unsigned int i = 0xcccccccc; unsigned int j; p = (char *) &i; printf("%.2x %.2x %.2x %.2x\n", *p, p[1], p[2], p[3]); memcpy(&j, p, sizeof(unsigned int)); printf("%x\n", j); ... Output: ffffffcc ffffffcc ffffffcc ffffffcc 0xcccccccc My questions are: 1. Why it prints "ffffffcc ffffffcc ffffffcc ffffffcc"? (if p is unsigned char* then it will print correctly "cc cc cc cc") 2. Why pointer to char p copied to j correctly, why not every member in p overflow? since it is a signed char. 这是别人在邮件列表中提出的问题，在试图回答这个问题的过程中，突然发现，自己对连接器的工作并不熟悉，因此拿来好书《程序员的自我修养》来看，并做如下汇报，强烈推荐《程序员的自我修养》！！！写好的C语言文件，最终能够执行，大致要经过预处理、编译、汇编、链接、装载五个过程。预编译完成的工作： （1）将所有的"#define"删除，并展开所有的宏定义 （2）处理所有条件预编译指令 （3）处理#include预编译指令，将被包含的文件插入到预编译指令的位置，这个过程是递归进行的。 （4）删除所有的注释 （5）添加行号和文件名标识，以便调试 （6）保留所有的#pragma编译器命令，因为编译器需要使用它们。编译完成的工作： （1）词法分析 扫描源代码序列，并将其分割为一系列的记号（Token）。 （2）语法分析 用语法分析器生成语法树，确定运算符号的优先级和含义、报告语法错误。 （3）语义分析 静态语义分析包括生命和类型的匹配，类型的转换；动态语义分析一般是在运行期出现的与语义相关性的问题，如除0错。 （4）源代码生成 源代码级优化器在源代码级别进行优化：如将如（6+2）之类的表达式，直接优化为（8）等等。将语法书转换为中间代码，如三地址码、P-代码等。 （5）代码生成 将源代码转换为目标代码，依赖于目标机器。 （6）目标代码优化汇编完成的工作： 将汇编代码变成机器可以执行的指令链接完成的工作： 链接完成的工作主要是将各个模块之间相互引用的部分处理好，使得各个模块之间正确衔接。链接过程包括：地址和空间分配、符号决议和重定位。 首先讲静态链接，基本的静态链接如下： 我们可能在main函数中调用到定义在另一个文件中的函数foo()，但是由于每个模块式单独编译的，因此main并不知道foo的地址，所以它暂时把这些调用foo的指令的目标地址搁置，等到最后链接的时候让连接器去修正这些地址（重定位），这就是静态链接最基本的过程和作用；对于定义在其他文件中的变量，也存在相同的问题。具体过程如下： （1）空间和地址分配 1）空间与地址分配：扫描所有输入目标文件，获得各个段的属性、长度和位置，并且将目标文件中的符号表中所有的符号定义和符号引用收集起来，放到一个全局符号表中。 2）符号解析和重定位：使用第一步收集到的信息，读取输入文件中段的数据、重定位信息，并进行符号解析与重定位、调整代码中的地址等。 动态链接的过程更为复杂，但是完成的工作类似。 动态链接的初衷是为了解决空间浪费和更新困难的问题，把链接过程推迟到运行时进行 首先介绍一个重要的概念——地址无关代码。为了解决固定装载地址冲突的问题，我们希望对所有绝对地址的引用不作重定位，而把这一步推迟到装载的时候再完成，一旦模块装载地址确定，即目标地址确定，那么系统对程序中所有的绝对地址引用进行重定位。同时我们希望，模块中共享的指令部分在装载时不需要因为装载地址的改变而改变，所以把指令中那些需要被修改的部分分离出来，跟数据放在一起，这样指令部分就可以保持不变，而数据部分可以在每个进程中拥有一个副本，这种方案目前被称为地址无关代码（PIC，Position-independent Code）。 我们需要解决如下四种引用中的重定位问题： 1）模块内部调用或者跳转：这个可以用相对地址调用或者基于寄存器的相对调用，所以不需要重定位2）模块内部数据的访问：用相对寻址的方法，不过链接器实现得十分巧妙： call494 add$0x188c, %ecx mov$0x1, 0x28(%ecx) //a=1 调用一个叫做__i686.get_pc_thunk.cx的函数，把call的下一条指令的地址放到ecx寄存器中，接着执行一条mov指令和一个add指令3）模块间数据的访问：在数据段里建立一个指向全局变量的指针数组，也成全局便宜表（GOT），当要引用全局变量时，可以通过GOT相对应的项间接引用： GOT是做到指令无关的重要的一环：在编译时可以确定GOT相对于当前指令的偏移，根据变量地址在GOT中的偏移就可以得到变量的地址，当然GOT中哪个每个地址对应于哪个变量是由编译器决定的。4）模块间的调用、跳转：采用上面类似的方法，不同的是GOT中相应的项存储的是目标函数的地址，当模块需要调用目标函数时，可以通过GOT中的项进行间接跳转。 地址无关代码小结： 现在，来看动态链接中的另一个重要问题——延迟绑定（PLT）。当函数第一次被用到时才进行绑定，否则不绑定。PLT为了实现延迟绑定，增加了一层间接跳转。调用函数并不是通过GOT跳转的，而是通过一个叫PLT项的结构进行跳转的，每个外部函数在PLT中都有对应的项，如函数bar，其在PLT对应的项的地址记为bar@plt，实现方式如下： bar@plt: jmp* (bar@GOT) pushn pushmoleID jump_dl_runtime_resolve 链接器的这个实现至为巧妙： 如果在连接器初始化阶段，已经正确的初始化了bar@GOT，那么这个跳转指令的结果正是我们所期望的，但是，为了实现PLT，一般在连接器初始化时，将"pushn"的地址放入到bar@GOT中，这样就直接跳转到第二条指令，相当于没有进行任何操作。第二条指令“pushn”，n是bar这个符号引用在重定位表“.rel.plt”中的下标。接着将模块的ID压栈，跳转到_dl_runtime_resolve完成符号解析和重定位工作，然后将bar的地址填入到bar@GOT中。下次再调用到bar时，则bar@GOT中存储的是一个正确的地址，这样就完成了整个过程。 在链接完成之后，就生成了你要的可执行文件了，如ELF文件，至于这个文件的详细的信息，可以参考相关的文档。 现在，你要运行你的可执行文件，这是如何做到的呢？ 我们从操作系统的角度来看可执行文件的装载过程。操作系统主要做如下三件事情：（1）创建一个独立的虚拟地址空间，但由于采用了COW机制，这里只是复制了父进程的页目录和页表，甚至不设置映射关系（参考操作系统相关书籍）。（2）读取可执行文件头，并且建立虚拟空间与可执行文件的映射关系。（3）将CPU的指令寄存器设置成可执行文件的入口地址，启动运行。我们来看一下执行过程中，进程虚拟空间的分布。 首先我们来区分Section和Segment，都可以翻译为“段”，那么有什么不同呢？从链接的角度来讲，elf文件是按照Section存储的，从装载的角度讲，elf文件是按照Segment存储的。”Segment”实际上是从装载的角度重新划分了ELF的各个段，将其中属性相似的Section合并为一个Segment，而系统是按照Segment来映射可执行文件的。
㈩ 求 《程序员的自我修养》pdf
http://ke..com/view/3122513.html?wtp=tt