From mboxrd@z Thu Jan 1 00:00:00 1970 From: mcgrof@kernel.org Subject: [PATCH v4 08/16] kbuild: enable option to force compile force-obj-y and force-lib-y Date: Fri, 19 Aug 2016 14:32:57 -0700 Message-ID: <1471642385-5629-9-git-send-email-mcgrof@kernel.org> References: <1471642385-5629-1-git-send-email-mcgrof@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1471642385-5629-1-git-send-email-mcgrof@kernel.org> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: hpa@zytor.com, tglx@linutronix.de, mingo@redhat.com, jpoimboe@redhat.com, bp@alien8.de, linux@arm.linux.org.uk, mhiramat@kernel.org, masami.hiramatsu.pt@hitachi.com, jbaron@akamai.com, heiko.carstens@de.ibm.com, ananth@linux.vnet.ibm.com, anil.s.keshavamurthy@intel.com, davem@davemloft.net, realmz6@gmail.com Cc: gnomes@lxorguk.ukuu.org.uk, linux-ia64@vger.kernel.org, jkosina@suse.cz, benh@kernel.crashing.org, ming.lei@canonical.com, linux@rasmusvillemoes.dk, platform-driver-x86@vger.kernel.org, James.Bottomley@HansenPartnership.com, paul.gortmaker@windriver.com, paulus@samba.org, sparclinux@vger.kernel.org, mchehab@osg.samsung.com, linux-arch@vger.kernel.org, markus.heiser@darmarit.de, xen-devel@lists.xensource.com, msalter@redhat.com, linux-sh@vger.kernel.org, mpe@ellerman.id.au, x86@kernel.org, fontana@sharpeleven.org, linux-arm-kernel@lists.infradead.org, catalin.marinas@arm.com, dvhart@infradead.org, dwmw2@infradead.org, linux-xtensa@linux-xtensa.org, pali.rohar@gmail.com, keescook@chromium.org, arnd@arndb.de, jani.nikula@intel.com, will.deacon@arm.com, rusty@rustcorp.com.au, rostedt@goodmis.org, acme@redhat.com, ak@linux.intel.com, andriy.shevchenko@linux.intel.com, mcb30@ip List-Id: linux-arch.vger.kernel.org RnJvbTogIkx1aXMgUi4gUm9kcmlndWV6IiA8bWNncm9mQGtlcm5lbC5vcmc+CgpMaW51eCBwcm92 aWRlcyBhIHJpY2ggYXJyYXkgb2YgZmVhdHVyZXMsIGVuYWJsaW5nIGVhY2ggZmVhdHVyZQpob3dl dmVyIGluY3JlYXNlcyB0aGUgc2l6ZSBvZiB0aGUga2VybmVsIGFuZCB0aGVyZSBhcmUgbWFueQpm ZWF0dXJlcyB3aGljaCB1c2VycyBvZnRlbiB3YW50IGRpc2FibGVkLiBUaGUgdHJhZGl0aW9uYWwK c29sdXRpb24gdG8gdGhpcyBwcm9ibGVtIGlzIGZvciBlYWNoIGZlYXR1cmUgdG8gaGF2ZSBpdHMg b3duCktjb25maWcgc3ltYm9sLCBmb2xsb3dlZCBieSBhIHNlcmllcyBvZiAjaWZkZWYgc3RhdGVt ZW50cwppbiBDIGNvZGUgYW5kIGhlYWRlciBmaWxlcywgYWxsb3dpbmcgdGhlIGZlYXR1cmUgdG8g YmUgY29tcGlsZWQKb25seSB3aGVuIGRlc2lyYWJsZS4gQXMgdGhlIHZhcmlhYmlsaXR5IG9mIExp bnV4IGluY3JlYXNlcyBidWlsZAp0ZXN0cyBjYW4gYW5kIGFyZSBvZnRlbiBkb25lIHdpdGggcmFu ZG9tIGtlcm5lbCBjb25maWd1cmF0aW9ucywKYWxseWVzY29uZmlnLCBhbmQgYWxsbW9kY29uZmln IHRvIGhlbHAgZmluZCBjb2RlIGlzc3Vlcy4gVGhpcwpob3dldmVyIGRvZXNuJ3QgY2F0Y2ggYWxs IGVycm9ycyBhbmQgYXMgYSBjb25zZXF1ZW5jZSBjb2RlIHRoYXQKaXMgdHlwaWNhbGx5IG5vdCBl bmFibGVkIG9mdGVuIGNhbiBzdWZmZXIgZnJvbSBiaXQtcm90IG92ZXIgdGltZS4KCkFuIGFsdGVy bmF0aXZlIGFwcHJvYWNoIGZvciBzdWJzeXN0ZW1zLCB3aGljaCByZWZlciB0byBhcyB0aGUgJ2J1 aWxkLWFsbApsaW5rLXNlbGVjdGl2ZWx5IHBoaWxvc29waHknIGlzIHRvIGtlZXAgdGhlIEtjb25m aWcgc3ltYm9scywgcmVwbGFjZQp0aGUgI2lmZGVmIGFwcHJvYWNoIGJ5IGhhdmluZyBlYWNoIGZl YXR1cmUgaW1wbGVtZW50ZWQgaXQgaXRzIG93biBDIGZpbGUsCmFuZCBmb3JjZSBjb21waWxhdGlv biBmb3IgYWxsIGZlYXR1cmVzIHRvIGF2b2lkIHRoZSBjb2RlIGJpdC1yb3QgcHJvYmxlbS4KV2l0 aCB0aGlzIHN0cmF0ZWd5IG9ubHkgZmVhdHVyZXMgdGhhdCBhcmUgZW5hYmxlZCB2aWEgS2NvbmZp ZyBnZXQKbGlua2VkIGludG8gdGhlIGtlcm5lbCwgc28gdGhlIGZvcmNlZCBjb21waWxhdGlvbiBo YXMgbm8gc2l6ZSBpbXBhY3QKb24gdGhlIGtlcm5lbC4gVGhlIHByYWN0aWNlIG9mIGhhdmluZyBl YWNoIGZlYXR1cmUgaW1wbGVtZW50ZWQgaW4gaXRzIG93bgpDIGZpbGUgaXMgYWxyZWFkeSBwcmV2 YWxlbnQgaW4gbWFueSBzdWJzeXN0ZW1zLCBob3dldmVyICNpZmRlZnMgYXJlIHN0aWxsCnR5cGlj YWxseSByZXF1aXJlZCBkdXJpbmcgZmVhdHVyZSBpbml0aWFsaXphdGlvbi4gRm9yIGluc3RhbmNl IGluOgoKICAjaWZkZWYgQ09ORklHX0ZPTwogIGZvb19pbml0KCk7CiAgI2VuZGlmCgpXZSBjYW5u b3QgcmVtb3ZlIHRoZSAjaWZkZWYgYW5kIGxlYXZlIGZvb19pbml0KCkgYXMgd2UnZCBlaXRoZXIK bmVlZCB0byBhbHdheXMgZW5hYmxlIHRoZSBmZWF0dXJlIG9yIGFkZCBhIHJlc3BlY3RpdmUgI2lm ZGVmIGluIGEKZm9vLmggd2hpY2ggbWFrZXMgZm9vX2luaXQoKSBkbyBub3RoaW5nIHdoZW4gQ09O RklHX0ZPTyBpcyBkaXNhYmxlZC4KCkxpbmtlciB0YWJsZXMgZW5hYmxlIGxpZnRpbmcgdGhlIHJl cXVpcmVtZW50IHRvIHVzZSBvZiAjaWZkZWZzIGR1cmluZwppbml0aWFsaXphdGlvbi4gV2l0aCBs aW5rZXIgdGFibGVzIGluaXRpYWxpemF0aW9uIHNlcXVlbmNlcyBjYW4gaW5zdGVhZApiZSBhZ2dy ZWdhdGVkIGludG8gYSBjdXN0b20gRUxGIHNlY3Rpb24gYXQgbGluayB0aW1lLCBkdXJpbmcgcnVu IHRpbWUKdGhlIHRhYmxlIGNhbiBiZSBpdGVyYXRlZCBvdmVyIGFuZCBlYWNoIGluaXQgc2VxdWVu Y2UgZW5hYmxlZCBjYW4gYmUgY2FsbGVkLgpBIGZlYXR1cmUncyBpbml0IHJvdXRpbmUgaXMgb25s eSBhZGRlZCB0byBhIHRhYmxlIHdoZW4gaXRzIHJlc3BlY3RpdmUKS2NvbmZpZyBzeW1ib2xzIGhh cyBiZWVuIGVuYWJsZWQgYW5kIHRoZXJlZm9yZSBsaW5rZWQgaW4uIExpbmtlciB0YWJsZXMKZW5h YmxlIHN1YnN5c3RlbXMgdG8gY29tcGxldGVseSBkbyBhd2F5IHdpdGggI2lmZGVmcyBpZiBvbmUg aXMgY29tZm9ydGFibGUKaW4gYWNjZXB0aW5nIGFsbCBzdWJzeXN0ZW0ncyBmZWF0dXJlJ3Mgc3Ry dWN0dXJhbCBzaXplIGltcGxpY2F0aW9ucy4KClN1YnN5c3RlbXMgd2hpY2ggd2FudCB0byBmb2xs b3cgdGhlICdidWlsZC1hbGwgbGluay1zZWxlY3RpdmVseQpwaGlsb3NvcGh5JyBzdGlsbCBuZWVk IGEgd2F5IHRvIGVhc2lseSBleHByZXNzIGFuZCBhbm5vdGF0ZSB0aGF0IHRoZXkKd2lzaCBmb3Ig YWxsIGNvZGUgdG8gYWx3YXlzIGJlIGNvbXBpbGVkIHRvIGhlbHAgYXZvaWQgY29kZSBiaXQgcm90 LAphcyBzdWNoIHR3byBuZXcgdGFyZ2V0cyBmb3JjZS1vYmoteSBhbmQgZm9yY2UtbGliLXkgYXJl IHByb3ZpZGVkIHRvCmhlbHAgd2l0aCB0aGlzLiBJdHMgbm90IGZhaXIgdG8gcmVxdWlyZSBldmVy eW9uZSB0byBmb3JjZSBjb21waWxhdGlvbgpvZiBhbGwgZmVhdHVyZXMgb2YgYSBzdWJzeXN0ZW0g dGhvdWdoLCBzbyBhcyBhIGNvbXByb21pc2UsIHRoZSBuZXcKdGFyZ2V0cyBvbmx5IGZvcmNlIGNv bXBpbGF0aW9uIHdoZW4gQ09ORklHX0JVSUxEX0FWT0lEX0JJVFJPVCBpcwplbmFibGVkLgoKT25s eSBidWlsdC1pbiBmZWF0dXJlcyBhcmUgc3VwcG9ydGVkIGF0IHRoZSBtb21lbnQuIE1vZHVsZSBz dXBwb3J0CmlzIGV4cGVjdGVkIHRvIGJlIGFkZGVkIGFmdGVyIGEgZ2VuZXJpYyBzb2x1dGlvbiB0 byBhZGQgbGlua2VyCnRhYmxlcyB0byBtb2R1bGVzIG1vcmUgZWFzaWx5IGlzIGRldmVsb3BlZC4K CnY0OiB0aGlzIHBhdGNoIHdhcyBhZGRlZCB0byB0aGlzIHNlcmllcywgaXQgd2FzIHNwbGl0IG9m ZiBmcm9tIHRoZQogICAgbGlua2VyIHRhYmxlcyBhZGRpdGlvbiBkdWUgdG8gdGhlIGNvbmZ1c2lv biBvdmVyIHRoZSBjb2RlIGJpdAogICAgcm90IGFsdGVybmF0aXZlcyB0aGF0IGFyZSBwb3NzaWJs ZSB3aXRoIGxpbmtlciB0YWJsZXMuCgpTaWduZWQtb2ZmLWJ5OiBMdWlzIFIuIFJvZHJpZ3VleiA8 bWNncm9mQGtlcm5lbC5vcmc+Ci0tLQogRG9jdW1lbnRhdGlvbi9rYnVpbGQvbWFrZWZpbGVzLnR4 dCAgICAgICB8IDM2ICsrKysrKysrKysrKysrKysKIERvY3VtZW50YXRpb24vc2VjdGlvbnMvbGlu a2VyLXRhYmxlcy5yc3QgfCAxNSArKysrKysrCiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5oICAgICAg ICAgICAgICAgICAgIHwgNzEgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIGluaXQv S2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAyMiArKysrKysrKysrCiBzY3Jp cHRzL01ha2VmaWxlLmJ1aWxkICAgICAgICAgICAgICAgICAgIHwgIDcgKystLQogc2NyaXB0cy9N YWtlZmlsZS5saWIgICAgICAgICAgICAgICAgICAgICB8IDExICsrKysrCiA2IGZpbGVzIGNoYW5n ZWQsIDE1OSBpbnNlcnRpb25zKCspLCAzIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL0RvY3Vt ZW50YXRpb24va2J1aWxkL21ha2VmaWxlcy50eHQgYi9Eb2N1bWVudGF0aW9uL2tidWlsZC9tYWtl ZmlsZXMudHh0CmluZGV4IDM4NWE1ZWY0MWMxNy4uMDFjMjYwOTEzZjVjIDEwMDY0NAotLS0gYS9E b2N1bWVudGF0aW9uL2tidWlsZC9tYWtlZmlsZXMudHh0CisrKyBiL0RvY3VtZW50YXRpb24va2J1 aWxkL21ha2VmaWxlcy50eHQKQEAgLTEwODksNiArMTA4OSw0MiBAQCBXaGVuIGtidWlsZCBleGVj dXRlcywgdGhlIGZvbGxvd2luZyBzdGVwcyBhcmUgZm9sbG93ZWQgKHJvdWdobHkpOgogCUluIHRo aXMgZXhhbXBsZSwgZXh0cmEteSBpcyB1c2VkIHRvIGxpc3Qgb2JqZWN0IGZpbGVzIHRoYXQKIAlz aGFsbCBiZSBidWlsdCwgYnV0IHNoYWxsIG5vdCBiZSBsaW5rZWQgYXMgcGFydCBvZiBidWlsdC1p bi5vLgogCisgICAgZm9yY2Utb2JqLXkgZm9yY2UtbGliLXkKKworCVdoZW4gQ09ORklHX0JVSUxE X0FWT0lEX0JJVFJPVCBpcyBlbmFibGVkIHVzaW5nIHRoZXNlIHRhcmdldHMgZm9yIHlvdXIKKwlr Y29uZmlnIHN5bWJvbHMgZm9yY2VzIGNvbXBpbGF0aW9uIG9mIHRoZSBhc3NvY2lhdGVkIG9iamVj dHMgaWYgdGhlCisJa2NvbmZpZydzIHN5bWJvbCdzIGRlcGVuZGVuY2llcyBhcmUgbWV0LCB0aGUg b2JqZWN0cyBob3dldmVyIGFyZSBvbmx5CisJbGlua2VkIGludG8gdG8gdGhlIGtlcm5lbCBpZiBh bmQgb25seSBpZiB0aGUga2NvbmZpZyBzeW1ib2wgd2FzCisJZW5hYmxlZC4gSWYgQ09ORklHX0JV SUxEX0FWT0lEX0JJVFJPVCBpcyBkaXNhYmxlZCB0aGUgZm9yY2Utb2JqLXkgYW5kCisJZm9yY2Ut bGliLXkgdGFyZ2V0cyBhcmUgZnVuY3Rpb25hbGx5IGVxdWlsdmFsZW50IHRvIG9iai15IGFuZCBs aWIteQorCXJlc3BlY3RpdmVseS4KKworCVVzaW5nIGZvcmNlLW9iai15IGFuZCBmb3JjZS1saWIt eSBhcmUgcGFydCBvZiBhIGNvZGUgYXJjaGl0ZWN0dXJlIGFuZAorCWJ1aWxkIHBoaWxvc29waHkg ZnVydGhlciBlbmFibGVkIGJ5IGxpbmtlciB0YWJsZXMsIGZvciBtb3JlIGRldGFpbHMKKwlyZWZl ciB0byB0aGUgZG9jdW1lbnRpb24gaW4gaW5jbHVkZS9saW51eC90YWJsZXMuaCwgcmVmZXIgdG8g dGhlCisJc2VjdGlvbnM6CisKKwkJbyBUaGUgY29kZSBiaXQtcm90IHByb2JsZW0KKwkJbyBUaGUg YnVpbGQtYWxsIHNlbGVjdGl2ZS1saW5rIHBoaWxvc29waHkKKwkJbyBBdm9pZGluZyB0aGUgY29k ZSBiaXQtcm90IHByb2JsZW0gd2l0aCBsaW5rZXIgdGFibGVzCisJCW8gTGlua2VyIHRhYmxlIG1v ZHVsZSBzdXBwb3J0CisKKwlNb2R1bGVzIHN1cHBvcnQgaXMgZXhwZWN0ZWQgdG8gYmUgZW5oYW5j ZWQgaW4gdGhlIGZ1dHVyZSwgc28gZm9yIG5vdworCW9ubHkgYnVpbHQtaW4gZmVhdHVyZXMgYXJl IHN1cHBvcnRlZC4KKworCUV4YW1wbGUgdXNlOgorCisJCWZvcmNlLW9iai0kKENPTkZJR19GRUFU VVJFX0ZPTykgKz0gZm9vLm8KKworCUFuIGFsdGVybmF0aXZlIHRvIHVzaW5nIGZvcmNlLW9iai15 LCBpcyB0byB1c2UgZXh0cmEteSBmb2xsb3dlZCBieSB0aGUKKwlyZXNwZWN0aXZlIG9iai15Ogor CisJCWV4dHJhLXkgKz0gZm9vLm8KKwkJb2JqLSQoQ09ORklHX0ZFQVRVUkVfRk9PKSArPSBmb28u bworCisJVXNpbmcgZm9yY2Utb2JqLXkgYW5kIGZvcmNlLWxpYi15IGNhbiBiZSB1c2VkIHRvIGhl bHAgYW5ub3RhdGUgdGhlCisJdGFyZ2V0cyBmb2xsb3cgdGhlICdidWlsZC1hbGwgc2VsZWN0aXZl LWxpbmsgcGhpbG9zb3BoeScgZnVydGhlcgorCWVuYWJsZWQgYnkgbGlua2VyIHRhYmxlcy4KIAog LS0tIDYuNyBDb21tYW5kcyB1c2VmdWwgZm9yIGJ1aWxkaW5nIGEgYm9vdCBpbWFnZQogCmRpZmYg LS1naXQgYS9Eb2N1bWVudGF0aW9uL3NlY3Rpb25zL2xpbmtlci10YWJsZXMucnN0IGIvRG9jdW1l bnRhdGlvbi9zZWN0aW9ucy9saW5rZXItdGFibGVzLnJzdAppbmRleCBkZjExYzYzMmRjYTcuLmU0 MjVjNWNkMzZkNiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9saW5rZXItdGFi bGVzLnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL3NlY3Rpb25zL2xpbmtlci10YWJsZXMucnN0CkBA IC0zMCw2ICszMCwyMSBAQCBIb3cgbGlua2VyIHRhYmxlcyBzaW1wbGlmeSBpbml0aWFsaXphdGlv biBjb2RlCiAuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAogICAgOmRvYzog SG93IGxpbmtlciB0YWJsZXMgc2ltcGxpZnkgaW5pdGlhbGl6YXRpb24gY29kZQogCitUaGUgY29k ZSBiaXQtcm90IHByb2JsZW0KKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorLi4ga2VybmVsLWRv Yzo6IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpkb2M6IFRoZSBjb2RlIGJpdC1yb3QgcHJv YmxlbQorCitUaGUgYnVpbGQtYWxsIHNlbGVjdGl2ZS1saW5rIHBoaWxvc29waHkKKy0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUv bGludXgvdGFibGVzLmgKKyAgIDpkb2M6IFRoZSBidWlsZC1hbGwgc2VsZWN0aXZlLWxpbmsgcGhp bG9zb3BoeQorCitBdm9pZGluZyB0aGUgY29kZSBiaXQtcm90IHByb2JsZW0gd2l0aCBsaW5rZXIg dGFibGVzCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAorICAgOmRvYzogQXZv aWRpbmcgdGhlIGNvZGUgYml0LXJvdCBwcm9ibGVtIHdpdGggbGlua2VyIHRhYmxlcworCiBVc2lu ZyBsaW5rZXIgdGFibGVzIGluIExpbnV4CiA9PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAK ZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdGFibGVzLmggYi9pbmNsdWRlL2xpbnV4L3RhYmxl cy5oCmluZGV4IDQyMzgyN2VhZmI1Mi4uYmY4ZmFlN2Y5MjQ2IDEwMDY0NAotLS0gYS9pbmNsdWRl L2xpbnV4L3RhYmxlcy5oCisrKyBiL2luY2x1ZGUvbGludXgvdGFibGVzLmgKQEAgLTE2OSw2ICsx NjksNzcgQEAKICAqLwogCiAvKioKKyAqIERPQzogVGhlIGNvZGUgYml0LXJvdCBwcm9ibGVtCisg KgorICogTGludXggcHJvdmlkZXMgYSByaWNoIGFycmF5IG9mIGZlYXR1cmVzLCBlbmFibGluZyBl YWNoIGZlYXR1cmUKKyAqIGhvd2V2ZXIgaW5jcmVhc2VzIHRoZSBzaXplIG9mIHRoZSBrZXJuZWwg YW5kIHRoZXJlIGFyZSBtYW55CisgKiBmZWF0dXJlcyB3aGljaCB1c2VycyBvZnRlbiB3YW50IGRp c2FibGVkLiBUaGUgdHJhZGl0aW9uYWwKKyAqIHNvbHV0aW9uIHRvIHRoaXMgcHJvYmxlbSBpcyBm b3IgZWFjaCBmZWF0dXJlIHRvIGhhdmUgaXRzIG93bgorICogS2NvbmZpZyBzeW1ib2wsIGZvbGxv d2VkIGJ5IGEgc2VyaWVzIG9mICNpZmRlZiBzdGF0ZW1lbnRzCisgKiBpbiBDIGNvZGUgYW5kIGhl YWRlciBmaWxlcywgYWxsb3dpbmcgdGhlIGZlYXR1cmUgdG8gYmUgY29tcGlsZWQKKyAqIG9ubHkg d2hlbiBkZXNpcmFibGUuIEFzIHRoZSB2YXJpYWJpbGl0eSBvZiBMaW51eCBpbmNyZWFzZXMgYnVp bGQKKyAqIHRlc3RzIGNhbiBhbmQgYXJlIG9mdGVuIGRvbmUgd2l0aCByYW5kb20ga2VybmVsIGNv bmZpZ3VyYXRpb25zLAorICogYWxseWVzY29uZmlnLCBhbmQgYWxsbW9kY29uZmlnIHRvIGhlbHAg ZmluZCBjb2RlIGlzc3Vlcy4gVGhpcworICogaG93ZXZlciBkb2Vzbid0IGNhdGNoIGFsbCBlcnJv cnMgYW5kIGFzIGEgY29uc2VxdWVuY2UgY29kZSB0aGF0CisgKiBpcyB0eXBpY2FsbHkgbm90IGVu YWJsZWQgb2Z0ZW4gY2FuIHN1ZmZlciBmcm9tIGJpdC1yb3Qgb3ZlciB0aW1lLgorICovCisKKy8q KgorICogRE9DOiBUaGUgYnVpbGQtYWxsIHNlbGVjdGl2ZS1saW5rIHBoaWxvc29waHkKKyAqCisg KiBBIGNvZGUgYXJjaGl0ZWN0dXJlIHBoaWxvc29waHkgdG8gaGVscCBhdm9pZCBjb2RlIGJpdC1y b3QgY29uc2lzdHMKKyAqIG9mIHVzaW5nIEtjb25maWcgc3ltYm9scyBmb3IgZWFjaCBzdWJzeXN0 ZW0gZmVhdHVyZSwgcmVwbGFjZSBhbGwgI2lmZGVmcworICogYnkgaW5zdGVhZCBoYXZpbmcgZWFj aCBmZWF0dXJlIGltcGxlbWVudGVkIGl0IGl0cyBvd24gQyBmaWxlLCBhbmQgZm9yY2UKKyAqIGNv bXBpbGF0aW9uIGZvciBhbGwgZmVhdHVyZXMuIE9ubHkgZmVhdHVyZXMgdGhhdCBhcmUgZW5hYmxl ZCBnZXQgbGlua2VkIGluLAorICogdGhlIGZvcmNlZCBjb21waWxhdGlvbiB0aGVyZWZvcmUgaGFz IG5vIHNpemUgaW1wYWN0IG9uIHRoZSBmaW5hbCByZXN1bHQgb2YKKyAqIHRoZSBrZXJuZWwuIFRo ZSBwcmFjdGljZSBvZiBoYXZpbmcgZWFjaCBmZWF0dXJlIGltcGxlbWVudGVkIGluIGl0cyBvd24g QworICogZmlsZSBpcyBhbHJlYWR5IHByZXZhbGVudCBpbiBtYW55IHN1YnN5c3RlbXMsIGhvd2V2 ZXIgI2lmZGVmcyBhcmUgc3RpbGwKKyAqIHR5cGljYWxseSByZXF1aXJlZCBkdXJpbmcgZmVhdHVy ZSBpbml0aWFsaXphdGlvbi4gRm9yIGluc3RhbmNlIGluOjoKKyAqCisgKgkjaWZkZWYgQ09ORklH X0ZPTworICoJZm9vX2luaXQoKTsKKyAqCSNlbmRpZgorICoKKyAqIFdlIGNhbm5vdCByZW1vdmUg dGhlICNpZmRlZiBhbmQgbGVhdmUgZm9vX2luaXQoKSBhcyB3ZSdkIGVpdGhlcgorICogbmVlZCB0 byBhbHdheXMgZW5hYmxlIHRoZSBmZWF0dXJlIG9yIGFkZCBhIHJlc3BlY3RpdmUgI2lmZGVmIGlu IGEKKyAqIGZvby5oIHdoaWNoIG1ha2VzIGZvb19pbml0KCkgZG8gbm90aGluZyB3aGVuIGBgQ09O RklHX0ZPT2BgIGlzIGRpc2FibGVkLgorICovCisKKy8qKgorICogRE9DOiBBdm9pZGluZyB0aGUg Y29kZSBiaXQtcm90IHByb2JsZW0gd2l0aCBsaW5rZXIgdGFibGVzCisgKgorICogTGlua2VyIHRh YmxlcyBjYW4gYmUgdXNlZCB0byBmdXJ0aGVyIGhlbHAgYXZvaWQgdGhlIGNvZGUgYml0LXJvdCBw cm9ibGVtCisgKiB3aGVuIGVtYnJhY2luZyB0aGUgJ2J1aWxkLWFsbCBzZWxlY3RpdmUtbGluayBw aGlsb3NvcGh5JyBieSBsaWZ0aW5nIHRoZQorICogcmVxdWlyZW1lbnQgdG8gdXNlIG9mICNpZmRl ZnMgZHVyaW5nIGluaXRpYWxpemF0aW9uLiBXaXRoIGxpbmtlciB0YWJsZXMKKyAqIGluaXRpYWxp emF0aW9uIHNlcXVlbmNlcyBjYW4gYmUgYWdncmVnYXRlZCBpbnRvIGEgY3VzdG9tIEVMRiBzZWN0 aW9uIGF0CisgKiBsaW5rIHRpbWUsIGR1cmluZyBydW4gdGltZSB0aGUgdGFibGUgY2FuIGJlIGl0 ZXJhdGVkIG92ZXIgYW5kIGVhY2ggaW5pdAorICogc2VxdWVuY2UgZW5hYmxlZCBjYW4gYmUgY2Fs bGVkLiBBIGZlYXR1cmUncyBpbml0IHJvdXRpbmUgaXMgb25seSBhZGRlZCB0byBhCisgKiB0YWJs ZSB3aGVuIGl0cyByZXNwZWN0aXZlIEtjb25maWcgc3ltYm9scyBoYXMgYmVlbiBlbmFibGVkIGFu ZCB0aGVyZWZvcmUKKyAqIGxpbmtlZCBpbi4gTGlua2VyIHRhYmxlcyBlbmFibGUgc3Vic3lzdGVt cyB0byBjb21wbGV0ZWx5IGRvIGF3YXkgd2l0aAorICogI2lmZGVmcyBpZiBvbmUgaXMgY29tZm9y dGFibGUgaW4gYWNjZXB0aW5nIGFsbCBzdWJzeXN0ZW0ncyBmZWF0dXJlJ3MKKyAqIHN0cnVjdHVy YWwgc2l6ZSBpbXBsaWNhdGlvbnMuCisgKgorICogVG8gZnVydGhlciBoZWxwIHdpdGggdGhpcyB0 aGUgTGludXggYnVpbGQgc3lzdGVtIHN1cHBvcnRzIHR3byBzcGVjaWFsCisgKiB0YXJnZXRzLCBg YGZvcmNlLW9iai15YGAgYW5kIGBgZm9yY2UtbGliLXlgYC4gQSBzdWJzeXN0ZW0gd2hpY2ggd2Fu dHMgdG8KKyAqIGZvbGxvdyB0aGUgJ2J1aWxkLWFsbCBzZWxlY3RpdmUtbGluayBwaGlsb3NvcGh5 JyBjYW4gdXNlIHRoZXNlIHRhcmdldHMgZm9yIGEKKyAqIGZlYXR1cmUncyBrY29uZmlnIHN5bWJv bC4gVXNpbmcgdGhlc2UgdGFyZ2V0cyB3aWxsIGFsd2F5cyByZXF1aXJlCisgKiBjb21waWxhdGlv biBvZiB0aGUga2NvbmZpZydzIG9iamVjdHMgaWYgdGhlIGtjb25maWcgc3ltYm9sJ3MgZGVwZW5k ZW5jaWVzCisgKiBhcmUgbWV0IGJ1dCBvbmx5IGxpbmsgdGhlIG9iamVjdHMgaW50byB0aGUga2Vy bmVsLCBhbmQgdGhlcmVmb3JlIGVuYWJsZSB0aGUKKyAqIGZlYXR1cmUsIGlmIGFuZCBvbmx5IGlm IHRoZSBrY29uZmlnIHN5bWJvbCBoYXMgYmVlbiBlbmFibGVkLgorICoKKyAqIE5vdCBhbGwgdXNl cnMgb3IgYnVpbGQgc3lzdGVtcyBtYXkgd2FudCB0byBvcHQtaW4gdG8gY29tcGlsZSBhbGwgb2Jq ZWN0cworICogZm9sbG93aW5nIHRoZSAnYnVpbGQtYWxsIHNlbGVjdGl2ZS1saW5rIHBoaWxvc29w aHknLCBhcyBzdWNoIHRoZSB0YXJnZXRzCisgKiBgYGZvcmNlLW9iai15YGAgYW5kIGBgZm9yY2Ut bGliLXlgYCBvbmx5IGZvcmNlIGNvbXBpbGF0aW9uIHdoZW4gdGhlIGtjb25maWcKKyAqIHN5bWJv bCBgYENPTkZJR19CVUlMRF9BVk9JRF9CSVRST1RgYCBoYXMgYmVlbiBlbmFibGVkLiBEaXNhYmxp bmcgdGhpcyBmZWF0dXJlCisgKiBtYWtlcyBgYGZvcmNlLW9iai15YGAgYW5kIGBgZm9yY2UtbGli LXlgYCBmdW5jdGlvbmFsbHkgZXF1aXZhbGVudCB0bworICogYGBvYmoteWBgIGFuZCBgYGxpYi15 YGAgcmVzcGVjdGl2ZWx5LgorICoKKyAqIEV4YW1wbGUgdXNlOjoKKyAqCisgKiAJZm9yY2Utb2Jq LSQoQ09ORklHX0ZFQVRVUkVfRk9PKSArPSBmb28ubworICovCisKKy8qKgogICogRE9DOiBMaW5r ZXIgdGFibGUgbW9kdWxlIHN1cHBvcnQKICAqCiAgKiBNb2R1bGVzIGNhbiB1c2UgbGlua2VyIHRh YmxlcywgaG93ZXZlciB0aGUgbGlua2VyIHRhYmxlIGRlZmluaXRpb24KZGlmZiAtLWdpdCBhL2lu aXQvS2NvbmZpZyBiL2luaXQvS2NvbmZpZwppbmRleCBjYWMzZjA5NjA1MGQuLmVmMDllODNiOTE5 NiAxMDA2NDQKLS0tIGEvaW5pdC9LY29uZmlnCisrKyBiL2luaXQvS2NvbmZpZwpAQCAtNTMsNiAr NTMsMjggQEAgY29uZmlnIENST1NTX0NPTVBJTEUKIAkgIG5lZWQgdG8gc2V0IHRoaXMgdW5sZXNz IHlvdSB3YW50IHRoZSBjb25maWd1cmVkIGtlcm5lbCBidWlsZAogCSAgZGlyZWN0b3J5IHRvIHNl bGVjdCB0aGUgY3Jvc3MtY29tcGlsZXIgYXV0b21hdGljYWxseS4KIAorY29uZmlnIEJVSUxEX0FW T0lEX0JJVFJPVAorCWJvb2wgIkVuYWJsZSBmb3JjZSBidWlsZGluZyBvZiBmb3JjZS1vYmoteSBh bmQgZm9yY2UtbGliLXkiCisJZGVmYXVsdCBuCisJaGVscAorCSAgV2hlbiBlbmFibGVkIG9iamVj dHMgdW5kZXIgdGhlIGZvcmNlLW9iai15IGFuZCBmb3JjZS1saWIteSB0YXJnZXRzCisJICB1c2lu ZyBhIEtjb25maWcgc3ltYm9sIHdpbGwgYmUgZm9yY2VkIHRvIGNvbXBpbGUgaWYgdGhlIEtjb25m aWcKKwkgIHN5bWJvbCdzIGRlcGVuZGVuY2llcyBhcmUgbWV0IGJ1dCBvbmx5IGxpbmtlZCBpbnRv IHRoZSBrZXJuZWwgaWYKKwkgIHRoZSBLY29uZmlnIHN5bWJvbCBpcyBlbmFibGVkLiBJZiBhIEtj b25maWcgc3ltYm9sIG9uIGEgZm9yY2Utb2JqLXkKKwkgIG9yIGZvcmNlLWxpYi15IHRhcmdldCBp cyBkaXNhYmxlZCwgaXQgd2lsbCBiZSBjb21waWxlZCBidXQgbm90IGxpbmtlZAorCSAgaW50byB0 aGUga2VybmVsLgorCisJICBUaGUgZm9yY2Utb2JqLXkgYW5kIGZvcmNlLWxpYi15IHRhcmdldHMg Y2FuIGJlIHVzZWQgYnkgc3Vic3lzdGVtcworCSAgd2hpY2ggd2lzaCB0byB3YW50IHRvIGZvbGxv dyB0aGUgJ2J1aWxkLWFsbCBzZWxlY3RpdmUtbGluayBwaGlsb3NvcGh5JworCSAgZG9jdW1lbnRl ZCB1bmRlciBpbmNsdWRlL2xpbnV4L3RhYmxlcy5oLgorCisJICBTYXkgWSBpZiB5b3UgaGF2ZSBh IGRlY2VudCBidWlsZCBtYWNoaW5lIGFuZCB3b3VsZCBsaWtlIHRvIGhlbHAgdGVzdAorCSAgYnVp bGRpbmcgY29kZSBmb3IgbW9yZSBzdWJzeXN0ZW1zLiBTYXkgTiBpZiB5b3UgZG8geW91IG5vdCBo YXZlIGEKKwkgIGdvb2QgYnVpbGQgbWFjaGluZSBvciBvbmx5IHdhbnQgdG8gY29tcGlsZSB3aGF0 IHlvdSd2ZSBlbmFibGVkIGZvcgorCSAgeW91ciBrZXJuZWwuCisKKwkgIEVuYWJsaW5nIHRoaXMg b3B0aW9uIG5ldmVyIGluY3JlYXNlcyB0aGUgc2l6ZSBvZiB5b3VyIGtlcm5lbC4KKwogY29uZmln IENPTVBJTEVfVEVTVAogCWJvb2wgIkNvbXBpbGUgYWxzbyBkcml2ZXJzIHdoaWNoIHdpbGwgbm90 IGxvYWQiCiAJZGVwZW5kcyBvbiAhVU1MCmRpZmYgLS1naXQgYS9zY3JpcHRzL01ha2VmaWxlLmJ1 aWxkIGIvc2NyaXB0cy9NYWtlZmlsZS5idWlsZAppbmRleCBjZDliZjIyYmIwMjcuLmNjMmM3MjQx ZDE5MyAxMDA2NDQKLS0tIGEvc2NyaXB0cy9NYWtlZmlsZS5idWlsZAorKysgYi9zY3JpcHRzL01h a2VmaWxlLmJ1aWxkCkBAIC05Miw3ICs5Miw4IEBAIG1vZG9yZGVyLXRhcmdldCA6PSAkKG9iaikv bW9kdWxlcy5vcmRlcgogCiAjIFdlIGtlZXAgYSBsaXN0IG9mIGFsbCBtb2R1bGVzIGluICQoTU9E VkVSRElSKQogCi1fX2J1aWxkOiAkKGlmICQoS0JVSUxEX0JVSUxUSU4pLCQoYnVpbHRpbi10YXJn ZXQpICQobGliLXRhcmdldCkgJChleHRyYS15KSkgXAorX19idWlsZDogJChpZiAkKEtCVUlMRF9C VUlMVElOKSwkKGJ1aWx0aW4tdGFyZ2V0KSAkKGxpYi10YXJnZXQpICQoZXh0cmEteSkgXAorCQkJ CSQoZm9yY2Utb2JqLXkpKSBcCiAJICQoaWYgJChLQlVJTERfTU9EVUxFUyksJChvYmotbSkgJCht b2RvcmRlci10YXJnZXQpKSBcCiAJICQoc3ViZGlyLXltKSAkKGFsd2F5cykKIAlAOgpAQCAtMzI2 LDggKzMyNyw4IEBAIGNtZF9hc19vX1MgICAgICAgPSAkKENDKSAkKGFfZmxhZ3MpIC1jIC1vICRA ICQ8CiAkKG9iaikvJS5vOiAkKHNyYykvJS5TICQob2JqdG9vbF9vYmopIEZPUkNFCiAJJChjYWxs IGlmX2NoYW5nZWRfcnVsZSxhc19vX1MpCiAKLXRhcmdldHMgKz0gJChyZWFsLW9ianMteSkgJChy ZWFsLW9ianMtbSkgJChsaWIteSkKLXRhcmdldHMgKz0gJChleHRyYS15KSAkKE1BS0VDTURHT0FM UykgJChhbHdheXMpCit0YXJnZXRzICs9ICQocmVhbC1vYmpzLXkpICQocmVhbC1vYmpzLW0pICQo bGliLXkpICQoZm9yY2UtbGliLXkpCit0YXJnZXRzICs9ICQoZXh0cmEteSkgJChmb3JjZS1vYmot eSkgJChNQUtFQ01ER09BTFMpICQoYWx3YXlzKQogCiAjIExpbmtlciBzY3JpcHRzIHByZXByb2Nl c3NvciAoLmxkcy5TIC0+IC5sZHMpCiAjIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQpkaWZmIC0tZ2l0IGEv c2NyaXB0cy9NYWtlZmlsZS5saWIgYi9zY3JpcHRzL01ha2VmaWxlLmxpYgppbmRleCAwYTA3Zjkw MTQ5NDQuLmQxY2IwY2ZkZjFiZiAxMDA2NDQKLS0tIGEvc2NyaXB0cy9NYWtlZmlsZS5saWIKKysr IGIvc2NyaXB0cy9NYWtlZmlsZS5saWIKQEAgLTEyLDYgKzEyLDE1IEBAIGV4cG9ydCBLQlVJTERf U1VCRElSX0NDRkxBR1MgOj0gJChLQlVJTERfU1VCRElSX0NDRkxBR1MpICQoc3ViZGlyLWNjZmxh Z3MteSkKICMgRmlndXJlIG91dCB3aGF0IHdlIG5lZWQgdG8gYnVpbGQgZnJvbSB0aGUgdmFyaW91 cyB2YXJpYWJsZXMKICMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAKK2lmZXEgKCQoQ09ORklHX0JVSUxE X0FWT0lEX0JJVFJPVCkseSkKK2V4dHJhLXkgKz0gJChmb3JjZS1vYmotKSAkKGZvcmNlLWxpYi0p CitlbmRpZgorCitvYmotbSArPSAkKGZvcmNlLW9iai1tKQorb2JqLXkgKz0gJChmb3JjZS1vYmot eSkKK2xpYi1tICs9ICQoZm9yY2UtbGliLW0pCitsaWIteSArPSAkKGZvcmNlLWxpYi15KQorCiAj IFdoZW4gYW4gb2JqZWN0IGlzIGxpc3RlZCB0byBiZSBidWlsdCBjb21waWxlZC1pbiBhbmQgbW9k dWxhciwKICMgb25seSBidWlsZCB0aGUgY29tcGlsZWQtaW4gdmVyc2lvbgogCkBAIC03Miw2ICs4 MSw4IEBAIHJlYWwtb2Jqcy1tIDo9ICQoZm9yZWFjaCBtLCAkKG9iai1tKSwgJChpZiAkKHN0cmlw ICQoJChtOi5vPS1vYmpzKSkgJCgkKG06Lm89LXkpCiAjIEFkZCBzdWJkaXIgcGF0aAogCiBleHRy YS15CQk6PSAkKGFkZHByZWZpeCAkKG9iaikvLCQoZXh0cmEteSkpCitmb3JjZS1vYmoteQkJOj0g JChhZGRwcmVmaXggJChvYmopLywkKGZvcmNlLW9iai15KSkKK2ZvcmNlLW9iai1tCQk6PSAkKGFk ZHByZWZpeCAkKG9iaikvLCQoZm9yY2Utb2JqLW0pKQogYWx3YXlzCQk6PSAkKGFkZHByZWZpeCAk KG9iaikvLCQoYWx3YXlzKSkKIHRhcmdldHMJCTo9ICQoYWRkcHJlZml4ICQob2JqKS8sJCh0YXJn ZXRzKSkKIG1vZG9yZGVyCTo9ICQoYWRkcHJlZml4ICQob2JqKS8sJChtb2RvcmRlcikpCi0tIAoy LjkuMgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhl bi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbi5vcmcKaHR0cHM6Ly9saXN0 cy54ZW4ub3JnL3hlbi1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.kernel.org ([198.145.29.136]:38328 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754873AbcHSVey (ORCPT ); Fri, 19 Aug 2016 17:34:54 -0400 From: mcgrof@kernel.org Subject: [PATCH v4 08/16] kbuild: enable option to force compile force-obj-y and force-lib-y Date: Fri, 19 Aug 2016 14:32:57 -0700 Message-ID: <1471642385-5629-9-git-send-email-mcgrof@kernel.org> In-Reply-To: <1471642385-5629-1-git-send-email-mcgrof@kernel.org> References: <1471642385-5629-1-git-send-email-mcgrof@kernel.org> Sender: linux-arch-owner@vger.kernel.org List-ID: To: hpa@zytor.com, tglx@linutronix.de, mingo@redhat.com, jpoimboe@redhat.com, bp@alien8.de, linux@arm.linux.org.uk, mhiramat@kernel.org, masami.hiramatsu.pt@hitachi.com, jbaron@akamai.com, heiko.carstens@de.ibm.com, ananth@linux.vnet.ibm.com, anil.s.keshavamurthy@intel.com, davem@davemloft.net, realmz6@gmail.com Cc: x86@kernel.org, luto@amacapital.net, keescook@chromium.org, torvalds@linux-foundation.org, gregkh@linuxfoundation.org, rusty@rustcorp.com.au, gnomes@lxorguk.ukuu.org.uk, alan@linux.intel.com, dwmw2@infradead.org, arnd@arndb.de, ming.lei@canonical.com, linux-arch@vger.kernel.org, benh@kernel.crashing.org, ananth@in.ibm.com, pebolle@tiscali.nl, fontana@sharpeleven.org, david.vrabel@citrix.com, konrad.wilk@oracle.com, mcb30@ipxe.org, jgross@suse.com, andrew.cooper3@citrix.com, andriy.shevchenko@linux.intel.com, paul.gortmaker@windriver.com, xen-devel@lists.xensource.com, ak@linux.intel.com, pali.rohar@gmail.com, dvhart@infradead.org, platform-driver-x86@vger.kernel.org, mmarek@suse.com, linux@rasmusvillemoes.dk, jkosina@suse.cz, korea.drzix@gmail.com, linux-kbuild@vger.kernel.org, tony.luck@intel.com, akpm@linux-foundation.org, linux-ia64@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sh@vger.kernel.org, sparclinux@vger.kernel.org, catalin.marinas@arm.com, will.deacon@arm.com, rostedt@goodmis.org, jani.nikula@intel.com, mchehab@osg.samsung.com, markus.heiser@darmarit.de, acme@redhat.com, jolsa@kernel.org, msalter@redhat.com, chris@zankel.net, jcmvbkbc@gmail.com, linux-xtensa@linux-xtensa.org, paulus@samba.org, mpe@ellerman.id.au, James.Bottomley@HansenPartnership.com, "Luis R. Rodriguez" Message-ID: <20160819213257.Tj3eYd2XmhMjI81risZ24NhUwdTxEJbWBrGi1Wl4l3M@z> From: "Luis R. Rodriguez" Linux provides a rich array of features, enabling each feature however increases the size of the kernel and there are many features which users often want disabled. The traditional solution to this problem is for each feature to have its own Kconfig symbol, followed by a series of #ifdef statements in C code and header files, allowing the feature to be compiled only when desirable. As the variability of Linux increases build tests can and are often done with random kernel configurations, allyesconfig, and allmodconfig to help find code issues. This however doesn't catch all errors and as a consequence code that is typically not enabled often can suffer from bit-rot over time. An alternative approach for subsystems, which refer to as the 'build-all link-selectively philosophy' is to keep the Kconfig symbols, replace the #ifdef approach by having each feature implemented it its own C file, and force compilation for all features to avoid the code bit-rot problem. With this strategy only features that are enabled via Kconfig get linked into the kernel, so the forced compilation has no size impact on the kernel. The practice of having each feature implemented in its own C file is already prevalent in many subsystems, however #ifdefs are still typically required during feature initialization. For instance in: #ifdef CONFIG_FOO foo_init(); #endif We cannot remove the #ifdef and leave foo_init() as we'd either need to always enable the feature or add a respective #ifdef in a foo.h which makes foo_init() do nothing when CONFIG_FOO is disabled. Linker tables enable lifting the requirement to use of #ifdefs during initialization. With linker tables initialization sequences can instead be aggregated into a custom ELF section at link time, during run time the table can be iterated over and each init sequence enabled can be called. A feature's init routine is only added to a table when its respective Kconfig symbols has been enabled and therefore linked in. Linker tables enable subsystems to completely do away with #ifdefs if one is comfortable in accepting all subsystem's feature's structural size implications. Subsystems which want to follow the 'build-all link-selectively philosophy' still need a way to easily express and annotate that they wish for all code to always be compiled to help avoid code bit rot, as such two new targets force-obj-y and force-lib-y are provided to help with this. Its not fair to require everyone to force compilation of all features of a subsystem though, so as a compromise, the new targets only force compilation when CONFIG_BUILD_AVOID_BITROT is enabled. Only built-in features are supported at the moment. Module support is expected to be added after a generic solution to add linker tables to modules more easily is developed. v4: this patch was added to this series, it was split off from the linker tables addition due to the confusion over the code bit rot alternatives that are possible with linker tables. Signed-off-by: Luis R. Rodriguez --- Documentation/kbuild/makefiles.txt | 36 ++++++++++++++++ Documentation/sections/linker-tables.rst | 15 +++++++ include/linux/tables.h | 71 ++++++++++++++++++++++++++++++++ init/Kconfig | 22 ++++++++++ scripts/Makefile.build | 7 ++-- scripts/Makefile.lib | 11 +++++ 6 files changed, 159 insertions(+), 3 deletions(-) diff --git a/Documentation/kbuild/makefiles.txt b/Documentation/kbuild/makefiles.txt index 385a5ef41c17..01c260913f5c 100644 --- a/Documentation/kbuild/makefiles.txt +++ b/Documentation/kbuild/makefiles.txt @@ -1089,6 +1089,42 @@ When kbuild executes, the following steps are followed (roughly): In this example, extra-y is used to list object files that shall be built, but shall not be linked as part of built-in.o. + force-obj-y force-lib-y + + When CONFIG_BUILD_AVOID_BITROT is enabled using these targets for your + kconfig symbols forces compilation of the associated objects if the + kconfig's symbol's dependencies are met, the objects however are only + linked into to the kernel if and only if the kconfig symbol was + enabled. If CONFIG_BUILD_AVOID_BITROT is disabled the force-obj-y and + force-lib-y targets are functionally equilvalent to obj-y and lib-y + respectively. + + Using force-obj-y and force-lib-y are part of a code architecture and + build philosophy further enabled by linker tables, for more details + refer to the documention in include/linux/tables.h, refer to the + sections: + + o The code bit-rot problem + o The build-all selective-link philosophy + o Avoiding the code bit-rot problem with linker tables + o Linker table module support + + Modules support is expected to be enhanced in the future, so for now + only built-in features are supported. + + Example use: + + force-obj-$(CONFIG_FEATURE_FOO) += foo.o + + An alternative to using force-obj-y, is to use extra-y followed by the + respective obj-y: + + extra-y += foo.o + obj-$(CONFIG_FEATURE_FOO) += foo.o + + Using force-obj-y and force-lib-y can be used to help annotate the + targets follow the 'build-all selective-link philosophy' further + enabled by linker tables. --- 6.7 Commands useful for building a boot image diff --git a/Documentation/sections/linker-tables.rst b/Documentation/sections/linker-tables.rst index df11c632dca7..e425c5cd36d6 100644 --- a/Documentation/sections/linker-tables.rst +++ b/Documentation/sections/linker-tables.rst @@ -30,6 +30,21 @@ How linker tables simplify initialization code .. kernel-doc:: include/linux/tables.h :doc: How linker tables simplify initialization code +The code bit-rot problem +------------------------ +.. kernel-doc:: include/linux/tables.h + :doc: The code bit-rot problem + +The build-all selective-link philosophy +--------------------------------------- +.. kernel-doc:: include/linux/tables.h + :doc: The build-all selective-link philosophy + +Avoiding the code bit-rot problem with linker tables +---------------------------------------------------- +.. kernel-doc:: include/linux/tables.h + :doc: Avoiding the code bit-rot problem with linker tables + Using linker tables in Linux ============================ diff --git a/include/linux/tables.h b/include/linux/tables.h index 423827eafb52..bf8fae7f9246 100644 --- a/include/linux/tables.h +++ b/include/linux/tables.h @@ -169,6 +169,77 @@ */ /** + * DOC: The code bit-rot problem + * + * Linux provides a rich array of features, enabling each feature + * however increases the size of the kernel and there are many + * features which users often want disabled. The traditional + * solution to this problem is for each feature to have its own + * Kconfig symbol, followed by a series of #ifdef statements + * in C code and header files, allowing the feature to be compiled + * only when desirable. As the variability of Linux increases build + * tests can and are often done with random kernel configurations, + * allyesconfig, and allmodconfig to help find code issues. This + * however doesn't catch all errors and as a consequence code that + * is typically not enabled often can suffer from bit-rot over time. + */ + +/** + * DOC: The build-all selective-link philosophy + * + * A code architecture philosophy to help avoid code bit-rot consists + * of using Kconfig symbols for each subsystem feature, replace all #ifdefs + * by instead having each feature implemented it its own C file, and force + * compilation for all features. Only features that are enabled get linked in, + * the forced compilation therefore has no size impact on the final result of + * the kernel. The practice of having each feature implemented in its own C + * file is already prevalent in many subsystems, however #ifdefs are still + * typically required during feature initialization. For instance in:: + * + * #ifdef CONFIG_FOO + * foo_init(); + * #endif + * + * We cannot remove the #ifdef and leave foo_init() as we'd either + * need to always enable the feature or add a respective #ifdef in a + * foo.h which makes foo_init() do nothing when ``CONFIG_FOO`` is disabled. + */ + +/** + * DOC: Avoiding the code bit-rot problem with linker tables + * + * Linker tables can be used to further help avoid the code bit-rot problem + * when embracing the 'build-all selective-link philosophy' by lifting the + * requirement to use of #ifdefs during initialization. With linker tables + * initialization sequences can be aggregated into a custom ELF section at + * link time, during run time the table can be iterated over and each init + * sequence enabled can be called. A feature's init routine is only added to a + * table when its respective Kconfig symbols has been enabled and therefore + * linked in. Linker tables enable subsystems to completely do away with + * #ifdefs if one is comfortable in accepting all subsystem's feature's + * structural size implications. + * + * To further help with this the Linux build system supports two special + * targets, ``force-obj-y`` and ``force-lib-y``. A subsystem which wants to + * follow the 'build-all selective-link philosophy' can use these targets for a + * feature's kconfig symbol. Using these targets will always require + * compilation of the kconfig's objects if the kconfig symbol's dependencies + * are met but only link the objects into the kernel, and therefore enable the + * feature, if and only if the kconfig symbol has been enabled. + * + * Not all users or build systems may want to opt-in to compile all objects + * following the 'build-all selective-link philosophy', as such the targets + * ``force-obj-y`` and ``force-lib-y`` only force compilation when the kconfig + * symbol ``CONFIG_BUILD_AVOID_BITROT`` has been enabled. Disabling this feature + * makes ``force-obj-y`` and ``force-lib-y`` functionally equivalent to + * ``obj-y`` and ``lib-y`` respectively. + * + * Example use:: + * + * force-obj-$(CONFIG_FEATURE_FOO) += foo.o + */ + +/** * DOC: Linker table module support * * Modules can use linker tables, however the linker table definition diff --git a/init/Kconfig b/init/Kconfig index cac3f096050d..ef09e83b9196 100644 --- a/init/Kconfig +++ b/init/Kconfig @@ -53,6 +53,28 @@ config CROSS_COMPILE need to set this unless you want the configured kernel build directory to select the cross-compiler automatically. +config BUILD_AVOID_BITROT + bool "Enable force building of force-obj-y and force-lib-y" + default n + help + When enabled objects under the force-obj-y and force-lib-y targets + using a Kconfig symbol will be forced to compile if the Kconfig + symbol's dependencies are met but only linked into the kernel if + the Kconfig symbol is enabled. If a Kconfig symbol on a force-obj-y + or force-lib-y target is disabled, it will be compiled but not linked + into the kernel. + + The force-obj-y and force-lib-y targets can be used by subsystems + which wish to want to follow the 'build-all selective-link philosophy' + documented under include/linux/tables.h. + + Say Y if you have a decent build machine and would like to help test + building code for more subsystems. Say N if you do you not have a + good build machine or only want to compile what you've enabled for + your kernel. + + Enabling this option never increases the size of your kernel. + config COMPILE_TEST bool "Compile also drivers which will not load" depends on !UML diff --git a/scripts/Makefile.build b/scripts/Makefile.build index cd9bf22bb027..cc2c7241d193 100644 --- a/scripts/Makefile.build +++ b/scripts/Makefile.build @@ -92,7 +92,8 @@ modorder-target := $(obj)/modules.order # We keep a list of all modules in $(MODVERDIR) -__build: $(if $(KBUILD_BUILTIN),$(builtin-target) $(lib-target) $(extra-y)) \ +__build: $(if $(KBUILD_BUILTIN),$(builtin-target) $(lib-target) $(extra-y) \ + $(force-obj-y)) \ $(if $(KBUILD_MODULES),$(obj-m) $(modorder-target)) \ $(subdir-ym) $(always) @: @@ -326,8 +327,8 @@ cmd_as_o_S = $(CC) $(a_flags) -c -o $@ $< $(obj)/%.o: $(src)/%.S $(objtool_obj) FORCE $(call if_changed_rule,as_o_S) -targets += $(real-objs-y) $(real-objs-m) $(lib-y) -targets += $(extra-y) $(MAKECMDGOALS) $(always) +targets += $(real-objs-y) $(real-objs-m) $(lib-y) $(force-lib-y) +targets += $(extra-y) $(force-obj-y) $(MAKECMDGOALS) $(always) # Linker scripts preprocessor (.lds.S -> .lds) # --------------------------------------------------------------------------- diff --git a/scripts/Makefile.lib b/scripts/Makefile.lib index 0a07f9014944..d1cb0cfdf1bf 100644 --- a/scripts/Makefile.lib +++ b/scripts/Makefile.lib @@ -12,6 +12,15 @@ export KBUILD_SUBDIR_CCFLAGS := $(KBUILD_SUBDIR_CCFLAGS) $(subdir-ccflags-y) # Figure out what we need to build from the various variables # =========================================================================== +ifeq ($(CONFIG_BUILD_AVOID_BITROT),y) +extra-y += $(force-obj-) $(force-lib-) +endif + +obj-m += $(force-obj-m) +obj-y += $(force-obj-y) +lib-m += $(force-lib-m) +lib-y += $(force-lib-y) + # When an object is listed to be built compiled-in and modular, # only build the compiled-in version @@ -72,6 +81,8 @@ real-objs-m := $(foreach m, $(obj-m), $(if $(strip $($(m:.o=-objs)) $($(m:.o=-y) # Add subdir path extra-y := $(addprefix $(obj)/,$(extra-y)) +force-obj-y := $(addprefix $(obj)/,$(force-obj-y)) +force-obj-m := $(addprefix $(obj)/,$(force-obj-m)) always := $(addprefix $(obj)/,$(always)) targets := $(addprefix $(obj)/,$(targets)) modorder := $(addprefix $(obj)/,$(modorder)) -- 2.9.2