From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Luis R. Rodriguez" Subject: [PATCH v6 05/14] kbuild: enable option to force compile force-obj-y and force-lib-y Date: Mon, 9 Jan 2017 06:58:23 -0800 Message-ID: <20170109145833.11502-6-mcgrof@kernel.org> References: <20161222023811.21246-1-mcgrof@kernel.org> <20170109145833.11502-1-mcgrof@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20170109145833.11502-1-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, acme@redhat.com, tglx@linutronix.de, mingo@redhat.com, jpoimboe@redhat.com, bp@alien8.de, npiggin@gmail.com, 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, dalias@libc.org, linux@arm.linux.org.uk 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, wangnan0@huawei.com, 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, joro@8bytes.org, x86@kernel.org, fontana@sharpeleven.org, dsahern@gmail.com, linux-arm-kernel@lists.infradead.org, catalin.marinas@arm.com, dvhart@infradead.org, dwmw2@infradead.org, linux@roeck-us.net, 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, ak@ List-Id: linux-arch.vger.kernel.org TGludXggcHJvdmlkZXMgYSByaWNoIGFycmF5IG9mIGZlYXR1cmVzLCBlbmFibGluZyBlYWNoIGZl YXR1cmUKaG93ZXZlciBpbmNyZWFzZXMgdGhlIHNpemUgb2YgdGhlIGtlcm5lbCBhbmQgdGhlcmUg YXJlIG1hbnkKZmVhdHVyZXMgd2hpY2ggdXNlcnMgb2Z0ZW4gd2FudCBkaXNhYmxlZC4gVGhlIHRy YWRpdGlvbmFsCnNvbHV0aW9uIHRvIHRoaXMgcHJvYmxlbSBpcyBmb3IgZWFjaCBmZWF0dXJlIHRv IGhhdmUgaXRzIG93bgpLY29uZmlnIHN5bWJvbCwgZm9sbG93ZWQgYnkgYSBzZXJpZXMgb2YgI2lm ZGVmIHN0YXRlbWVudHMKaW4gQyBjb2RlIGFuZCBoZWFkZXIgZmlsZXMsIGFsbG93aW5nIHRoZSBm ZWF0dXJlIHRvIGJlIGNvbXBpbGVkCm9ubHkgd2hlbiBkZXNpcmFibGUuIEFzIHRoZSB2YXJpYWJp bGl0eSBvZiBMaW51eCBpbmNyZWFzZXMgYnVpbGQKdGVzdHMgY2FuIGFuZCBhcmUgb2Z0ZW4gZG9u ZSB3aXRoIHJhbmRvbSBrZXJuZWwgY29uZmlndXJhdGlvbnMsCmFsbHllc2NvbmZpZywgYW5kIGFs bG1vZGNvbmZpZyB0byBoZWxwIGZpbmQgY29kZSBpc3N1ZXMuIFRoaXMKaG93ZXZlciBkb2Vzbid0 IGNhdGNoIGFsbCBlcnJvcnMgYW5kIGFzIGEgY29uc2VxdWVuY2UgY29kZSB0aGF0CmlzIHR5cGlj YWxseSBub3QgZW5hYmxlZCBvZnRlbiBjYW4gc3VmZmVyIGZyb20gYml0LXJvdCBvdmVyIHRpbWUu CgpBbiBhbHRlcm5hdGl2ZSBhcHByb2FjaCBmb3Igc3Vic3lzdGVtcywgd2hpY2ggcmVmZXIgdG8g YXMgdGhlICdidWlsZC1hbGwKbGluay1zZWxlY3RpdmVseSBwaGlsb3NvcGh5JyBpcyB0byBrZWVw IHRoZSBLY29uZmlnIHN5bWJvbHMsIHJlcGxhY2UKdGhlICNpZmRlZiBhcHByb2FjaCBieSBoYXZp bmcgZWFjaCBmZWF0dXJlIGltcGxlbWVudGVkIGl0IGl0cyBvd24gQyBmaWxlLAphbmQgZm9yY2Ug Y29tcGlsYXRpb24gZm9yIGFsbCBmZWF0dXJlcyB0byBhdm9pZCB0aGUgY29kZSBiaXQtcm90IHBy b2JsZW0uCldpdGggdGhpcyBzdHJhdGVneSBvbmx5IGZlYXR1cmVzIHRoYXQgYXJlIGVuYWJsZWQg dmlhIEtjb25maWcgZ2V0CmxpbmtlZCBpbnRvIHRoZSBrZXJuZWwsIHNvIHRoZSBmb3JjZWQgY29t cGlsYXRpb24gaGFzIG5vIHNpemUgaW1wYWN0Cm9uIHRoZSBrZXJuZWwuIFRoZSBwcmFjdGljZSBv ZiBoYXZpbmcgZWFjaCBmZWF0dXJlIGltcGxlbWVudGVkIGluIGl0cyBvd24KQyBmaWxlIGlzIGFs cmVhZHkgcHJldmFsZW50IGluIG1hbnkgc3Vic3lzdGVtcywgaG93ZXZlciAjaWZkZWZzIGFyZSBz dGlsbAp0eXBpY2FsbHkgcmVxdWlyZWQgZHVyaW5nIGZlYXR1cmUgaW5pdGlhbGl6YXRpb24uIEZv ciBpbnN0YW5jZSBpbjoKCiAgI2lmZGVmIENPTkZJR19GT08KICBmb29faW5pdCgpOwogICNlbmRp ZgoKV2UgY2Fubm90IHJlbW92ZSB0aGUgI2lmZGVmIGFuZCBsZWF2ZSBmb29faW5pdCgpIGFzIHdl J2QgZWl0aGVyCm5lZWQgdG8gYWx3YXlzIGVuYWJsZSB0aGUgZmVhdHVyZSBvciBhZGQgYSByZXNw ZWN0aXZlICNpZmRlZiBpbiBhCmZvby5oIHdoaWNoIG1ha2VzIGZvb19pbml0KCkgZG8gbm90aGlu ZyB3aGVuIENPTkZJR19GT08gaXMgZGlzYWJsZWQuCgpMaW5rZXIgdGFibGVzIGVuYWJsZSBsaWZ0 aW5nIHRoZSByZXF1aXJlbWVudCB0byB1c2Ugb2YgI2lmZGVmcyBkdXJpbmcKaW5pdGlhbGl6YXRp b24uIFdpdGggbGlua2VyIHRhYmxlcyBpbml0aWFsaXphdGlvbiBzZXF1ZW5jZXMgY2FuIGluc3Rl YWQKYmUgYWdncmVnYXRlZCBpbnRvIGEgY3VzdG9tIEVMRiBzZWN0aW9uIGF0IGxpbmsgdGltZSwg ZHVyaW5nIHJ1biB0aW1lCnRoZSB0YWJsZSBjYW4gYmUgaXRlcmF0ZWQgb3ZlciBhbmQgZWFjaCBp bml0IHNlcXVlbmNlIGVuYWJsZWQgY2FuIGJlIGNhbGxlZC4KQSBmZWF0dXJlJ3MgaW5pdCByb3V0 aW5lIGlzIG9ubHkgYWRkZWQgdG8gYSB0YWJsZSB3aGVuIGl0cyByZXNwZWN0aXZlCktjb25maWcg c3ltYm9scyBoYXMgYmVlbiBlbmFibGVkIGFuZCB0aGVyZWZvcmUgbGlua2VkIGluLiBMaW5rZXIg dGFibGVzCmVuYWJsZSBzdWJzeXN0ZW1zIHRvIGNvbXBsZXRlbHkgZG8gYXdheSB3aXRoICNpZmRl ZnMgaWYgb25lIGlzIGNvbWZvcnRhYmxlCmluIGFjY2VwdGluZyBhbGwgc3Vic3lzdGVtJ3MgZmVh dHVyZSdzIHN0cnVjdHVyYWwgc2l6ZSBpbXBsaWNhdGlvbnMuCgpTdWJzeXN0ZW1zIHdoaWNoIHdh bnQgdG8gZm9sbG93IHRoZSAnYnVpbGQtYWxsIGxpbmstc2VsZWN0aXZlbHkKcGhpbG9zb3BoeScg c3RpbGwgbmVlZCBhIHdheSB0byBlYXNpbHkgZXhwcmVzcyBhbmQgYW5ub3RhdGUgdGhhdCB0aGV5 Cndpc2ggZm9yIGFsbCBjb2RlIHRvIGFsd2F5cyBiZSBjb21waWxlZCB0byBoZWxwIGF2b2lkIGNv ZGUgYml0IHJvdCwKYXMgc3VjaCB0d28gbmV3IHRhcmdldHMgZm9yY2Utb2JqLXkgYW5kIGZvcmNl LWxpYi15IGFyZSBwcm92aWRlZCB0bwpoZWxwIHdpdGggdGhpcy4gSXRzIG5vdCBmYWlyIHRvIHJl cXVpcmUgZXZlcnlvbmUgdG8gZm9yY2UgY29tcGlsYXRpb24Kb2YgYWxsIGZlYXR1cmVzIG9mIGEg c3Vic3lzdGVtIHRob3VnaCwgc28gYXMgYSBjb21wcm9taXNlLCB0aGUgbmV3CnRhcmdldHMgb25s eSBmb3JjZSBjb21waWxhdGlvbiB3aGVuIENPTkZJR19CVUlMRF9BVk9JRF9CSVRST1QgaXMKZW5h YmxlZC4KCk9ubHkgYnVpbHQtaW4gZmVhdHVyZXMgYXJlIHN1cHBvcnRlZCBhdCB0aGUgbW9tZW50 LiBNb2R1bGUgc3VwcG9ydAppcyBleHBlY3RlZCB0byBiZSBhZGRlZCBhZnRlciBhIGdlbmVyaWMg c29sdXRpb24gdG8gYWRkIGxpbmtlcgp0YWJsZXMgdG8gbW9kdWxlcyBtb3JlIGVhc2lseSBpcyBk ZXZlbG9wZWQuCgp2NDogdGhpcyBwYXRjaCB3YXMgYWRkZWQgdG8gdGhpcyBzZXJpZXMsIGl0IHdh cyBzcGxpdCBvZmYgZnJvbSB0aGUKICAgIGxpbmtlciB0YWJsZXMgYWRkaXRpb24gZHVlIHRvIHRo ZSBjb25mdXNpb24gb3ZlciB0aGUgY29kZSBiaXQKICAgIHJvdCBhbHRlcm5hdGl2ZXMgdGhhdCBh cmUgcG9zc2libGUgd2l0aCBsaW5rZXIgdGFibGVzLgoKU2lnbmVkLW9mZi1ieTogTHVpcyBSLiBS b2RyaWd1ZXogPG1jZ3JvZkBrZXJuZWwub3JnPgotLS0KIERvY3VtZW50YXRpb24va2J1aWxkL21h a2VmaWxlcy50eHQgICAgICAgfCAzNiArKysrKysrKysrKysrKysrCiBEb2N1bWVudGF0aW9uL3Nl Y3Rpb25zL2xpbmtlci10YWJsZXMucnN0IHwgMTUgKysrKysrKwogaW5jbHVkZS9saW51eC90YWJs ZXMuaCAgICAgICAgICAgICAgICAgICB8IDcxICsrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrCiBpbml0L0tjb25maWcgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMjIgKysrKysr KysrKwogc2NyaXB0cy9NYWtlZmlsZS5idWlsZCAgICAgICAgICAgICAgICAgICB8ICA3ICsrLS0K IHNjcmlwdHMvTWFrZWZpbGUuY2xlYW4gICAgICAgICAgICAgICAgICAgfCAgMiArCiBzY3JpcHRz L01ha2VmaWxlLmxpYiAgICAgICAgICAgICAgICAgICAgIHwgMTEgKysrKysKIDcgZmlsZXMgY2hh bmdlZCwgMTYxIGluc2VydGlvbnMoKyksIDMgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvRG9j dW1lbnRhdGlvbi9rYnVpbGQvbWFrZWZpbGVzLnR4dCBiL0RvY3VtZW50YXRpb24va2J1aWxkL21h a2VmaWxlcy50eHQKaW5kZXggOWI5YzQ3OTdmYzU1Li4xYWYyNzVjZDQ4NzkgMTAwNjQ0Ci0tLSBh L0RvY3VtZW50YXRpb24va2J1aWxkL21ha2VmaWxlcy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9r YnVpbGQvbWFrZWZpbGVzLnR4dApAQCAtMTA5MCw2ICsxMDkwLDQyIEBAIFdoZW4ga2J1aWxkIGV4 ZWN1dGVzLCB0aGUgZm9sbG93aW5nIHN0ZXBzIGFyZSBmb2xsb3dlZCAocm91Z2hseSk6CiAJSW4g dGhpcyBleGFtcGxlLCBleHRyYS15IGlzIHVzZWQgdG8gbGlzdCBvYmplY3QgZmlsZXMgdGhhdAog CXNoYWxsIGJlIGJ1aWx0LCBidXQgc2hhbGwgbm90IGJlIGxpbmtlZCBhcyBwYXJ0IG9mIGJ1aWx0 LWluLm8uCiAKKyAgICBmb3JjZS1vYmoteSBmb3JjZS1saWIteQorCisJV2hlbiBDT05GSUdfQlVJ TERfQVZPSURfQklUUk9UIGlzIGVuYWJsZWQgdXNpbmcgdGhlc2UgdGFyZ2V0cyBmb3IgeW91cgor CWtjb25maWcgc3ltYm9scyBmb3JjZXMgY29tcGlsYXRpb24gb2YgdGhlIGFzc29jaWF0ZWQgb2Jq ZWN0cyBpZiB0aGUKKwlrY29uZmlnJ3Mgc3ltYm9sJ3MgZGVwZW5kZW5jaWVzIGFyZSBtZXQsIHRo ZSBvYmplY3RzIGhvd2V2ZXIgYXJlIG9ubHkKKwlsaW5rZWQgaW50byB0byB0aGUga2VybmVsIGlm IGFuZCBvbmx5IGlmIHRoZSBrY29uZmlnIHN5bWJvbCB3YXMKKwllbmFibGVkLiBJZiBDT05GSUdf QlVJTERfQVZPSURfQklUUk9UIGlzIGRpc2FibGVkIHRoZSBmb3JjZS1vYmoteSBhbmQKKwlmb3Jj ZS1saWIteSB0YXJnZXRzIGFyZSBmdW5jdGlvbmFsbHkgZXF1aWx2YWxlbnQgdG8gb2JqLXkgYW5k IGxpYi15CisJcmVzcGVjdGl2ZWx5LgorCisJVXNpbmcgZm9yY2Utb2JqLXkgYW5kIGZvcmNlLWxp Yi15IGFyZSBwYXJ0IG9mIGEgY29kZSBhcmNoaXRlY3R1cmUgYW5kCisJYnVpbGQgcGhpbG9zb3Bo eSBmdXJ0aGVyIGVuYWJsZWQgYnkgbGlua2VyIHRhYmxlcywgZm9yIG1vcmUgZGV0YWlscworCXJl ZmVyIHRvIHRoZSBkb2N1bWVudGlvbiBpbiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5oLCByZWZlciB0 byB0aGUKKwlzZWN0aW9uczoKKworCQlvIFRoZSBjb2RlIGJpdC1yb3QgcHJvYmxlbQorCQlvIFRo ZSBidWlsZC1hbGwgc2VsZWN0aXZlLWxpbmsgcGhpbG9zb3BoeQorCQlvIEF2b2lkaW5nIHRoZSBj b2RlIGJpdC1yb3QgcHJvYmxlbSB3aXRoIGxpbmtlciB0YWJsZXMKKwkJbyBMaW5rZXIgdGFibGUg bW9kdWxlIHN1cHBvcnQKKworCU1vZHVsZXMgc3VwcG9ydCBpcyBleHBlY3RlZCB0byBiZSBlbmhh bmNlZCBpbiB0aGUgZnV0dXJlLCBzbyBmb3Igbm93CisJb25seSBidWlsdC1pbiBmZWF0dXJlcyBh cmUgc3VwcG9ydGVkLgorCisJRXhhbXBsZSB1c2U6CisKKwkJZm9yY2Utb2JqLSQoQ09ORklHX0ZF QVRVUkVfRk9PKSArPSBmb28ubworCisJQW4gYWx0ZXJuYXRpdmUgdG8gdXNpbmcgZm9yY2Utb2Jq LXksIGlzIHRvIHVzZSBleHRyYS15IGZvbGxvd2VkIGJ5IHRoZQorCXJlc3BlY3RpdmUgb2JqLXk6 CisKKwkJZXh0cmEteSArPSBmb28ubworCQlvYmotJChDT05GSUdfRkVBVFVSRV9GT08pICs9IGZv by5vCisKKwlVc2luZyBmb3JjZS1vYmoteSBhbmQgZm9yY2UtbGliLXkgY2FuIGJlIHVzZWQgdG8g aGVscCBhbm5vdGF0ZSB0aGUKKwl0YXJnZXRzIGZvbGxvdyB0aGUgJ2J1aWxkLWFsbCBzZWxlY3Rp dmUtbGluayBwaGlsb3NvcGh5JyBmdXJ0aGVyCisJZW5hYmxlZCBieSBsaW5rZXIgdGFibGVzLgog CiAtLS0gNi43IENvbW1hbmRzIHVzZWZ1bCBmb3IgYnVpbGRpbmcgYSBib290IGltYWdlCiAKZGlm ZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvbGlua2VyLXRhYmxlcy5yc3QgYi9Eb2N1 bWVudGF0aW9uL3NlY3Rpb25zL2xpbmtlci10YWJsZXMucnN0CmluZGV4IDc4MGEyOTJkMmQwMC4u YmMyZDlmNDZjZGU2IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3NlY3Rpb25zL2xpbmtlci10 YWJsZXMucnN0CisrKyBiL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvbGlua2VyLXRhYmxlcy5yc3QK QEAgLTMwLDYgKzMwLDIxIEBAIEhvdyBsaW5rZXIgdGFibGVzIHNpbXBsaWZ5IGluaXRpYWxpemF0 aW9uIGNvZGUKIC4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5oCiAgICA6ZG9j OiBIb3cgbGlua2VyIHRhYmxlcyBzaW1wbGlmeSBpbml0aWFsaXphdGlvbiBjb2RlCiAKK1RoZSBj b2RlIGJpdC1yb3QgcHJvYmxlbQorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwt ZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAorICAgOmRvYzogVGhlIGNvZGUgYml0LXJvdCBw cm9ibGVtCisKK1RoZSBidWlsZC1hbGwgc2VsZWN0aXZlLWxpbmsgcGhpbG9zb3BoeQorLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVk ZS9saW51eC90YWJsZXMuaAorICAgOmRvYzogVGhlIGJ1aWxkLWFsbCBzZWxlY3RpdmUtbGluayBw aGlsb3NvcGh5CisKK0F2b2lkaW5nIHRoZSBjb2RlIGJpdC1yb3QgcHJvYmxlbSB3aXRoIGxpbmtl ciB0YWJsZXMKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5oCisgICA6ZG9jOiBB dm9pZGluZyB0aGUgY29kZSBiaXQtcm90IHByb2JsZW0gd2l0aCBsaW5rZXIgdGFibGVzCisKIFVz aW5nIGxpbmtlciB0YWJsZXMgaW4gTGludXgKID09PT09PT09PT09PT09PT09PT09PT09PT09PT0K IApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC90YWJsZXMuaCBiL2luY2x1ZGUvbGludXgvdGFi bGVzLmgKaW5kZXggMWExODM4ZDUxOTUxLi43MGE0MWVkZmExMjcgMTAwNjQ0Ci0tLSBhL2luY2x1 ZGUvbGludXgvdGFibGVzLmgKKysrIGIvaW5jbHVkZS9saW51eC90YWJsZXMuaApAQCAtMTY5LDYg KzE2OSw3NyBAQAogICovCiAKIC8qKgorICogRE9DOiBUaGUgY29kZSBiaXQtcm90IHByb2JsZW0K KyAqCisgKiBMaW51eCBwcm92aWRlcyBhIHJpY2ggYXJyYXkgb2YgZmVhdHVyZXMsIGVuYWJsaW5n IGVhY2ggZmVhdHVyZQorICogaG93ZXZlciBpbmNyZWFzZXMgdGhlIHNpemUgb2YgdGhlIGtlcm5l bCBhbmQgdGhlcmUgYXJlIG1hbnkKKyAqIGZlYXR1cmVzIHdoaWNoIHVzZXJzIG9mdGVuIHdhbnQg ZGlzYWJsZWQuIFRoZSB0cmFkaXRpb25hbAorICogc29sdXRpb24gdG8gdGhpcyBwcm9ibGVtIGlz IGZvciBlYWNoIGZlYXR1cmUgdG8gaGF2ZSBpdHMgb3duCisgKiBLY29uZmlnIHN5bWJvbCwgZm9s bG93ZWQgYnkgYSBzZXJpZXMgb2YgI2lmZGVmIHN0YXRlbWVudHMKKyAqIGluIEMgY29kZSBhbmQg aGVhZGVyIGZpbGVzLCBhbGxvd2luZyB0aGUgZmVhdHVyZSB0byBiZSBjb21waWxlZAorICogb25s eSB3aGVuIGRlc2lyYWJsZS4gQXMgdGhlIHZhcmlhYmlsaXR5IG9mIExpbnV4IGluY3JlYXNlcyBi dWlsZAorICogdGVzdHMgY2FuIGFuZCBhcmUgb2Z0ZW4gZG9uZSB3aXRoIHJhbmRvbSBrZXJuZWwg Y29uZmlndXJhdGlvbnMsCisgKiBhbGx5ZXNjb25maWcsIGFuZCBhbGxtb2Rjb25maWcgdG8gaGVs cCBmaW5kIGNvZGUgaXNzdWVzLiBUaGlzCisgKiBob3dldmVyIGRvZXNuJ3QgY2F0Y2ggYWxsIGVy cm9ycyBhbmQgYXMgYSBjb25zZXF1ZW5jZSBjb2RlIHRoYXQKKyAqIGlzIHR5cGljYWxseSBub3Qg ZW5hYmxlZCBvZnRlbiBjYW4gc3VmZmVyIGZyb20gYml0LXJvdCBvdmVyIHRpbWUuCisgKi8KKwor LyoqCisgKiBET0M6IFRoZSBidWlsZC1hbGwgc2VsZWN0aXZlLWxpbmsgcGhpbG9zb3BoeQorICoK KyAqIEEgY29kZSBhcmNoaXRlY3R1cmUgcGhpbG9zb3BoeSB0byBoZWxwIGF2b2lkIGNvZGUgYml0 LXJvdCBjb25zaXN0cworICogb2YgdXNpbmcgS2NvbmZpZyBzeW1ib2xzIGZvciBlYWNoIHN1YnN5 c3RlbSBmZWF0dXJlLCByZXBsYWNlIGFsbCAjaWZkZWZzCisgKiBieSBpbnN0ZWFkIGhhdmluZyBl YWNoIGZlYXR1cmUgaW1wbGVtZW50ZWQgaXQgaXRzIG93biBDIGZpbGUsIGFuZCBmb3JjZQorICog Y29tcGlsYXRpb24gZm9yIGFsbCBmZWF0dXJlcy4gT25seSBmZWF0dXJlcyB0aGF0IGFyZSBlbmFi bGVkIGdldCBsaW5rZWQgaW4sCisgKiB0aGUgZm9yY2VkIGNvbXBpbGF0aW9uIHRoZXJlZm9yZSBo YXMgbm8gc2l6ZSBpbXBhY3Qgb24gdGhlIGZpbmFsIHJlc3VsdCBvZgorICogdGhlIGtlcm5lbC4g VGhlIHByYWN0aWNlIG9mIGhhdmluZyBlYWNoIGZlYXR1cmUgaW1wbGVtZW50ZWQgaW4gaXRzIG93 biBDCisgKiBmaWxlIGlzIGFscmVhZHkgcHJldmFsZW50IGluIG1hbnkgc3Vic3lzdGVtcywgaG93 ZXZlciAjaWZkZWZzIGFyZSBzdGlsbAorICogdHlwaWNhbGx5IHJlcXVpcmVkIGR1cmluZyBmZWF0 dXJlIGluaXRpYWxpemF0aW9uLiBGb3IgaW5zdGFuY2UgaW46OgorICoKKyAqCSNpZmRlZiBDT05G SUdfRk9PCisgKglmb29faW5pdCgpOworICoJI2VuZGlmCisgKgorICogV2UgY2Fubm90IHJlbW92 ZSB0aGUgI2lmZGVmIGFuZCBsZWF2ZSBmb29faW5pdCgpIGFzIHdlJ2QgZWl0aGVyCisgKiBuZWVk IHRvIGFsd2F5cyBlbmFibGUgdGhlIGZlYXR1cmUgb3IgYWRkIGEgcmVzcGVjdGl2ZSAjaWZkZWYg aW4gYQorICogZm9vLmggd2hpY2ggbWFrZXMgZm9vX2luaXQoKSBkbyBub3RoaW5nIHdoZW4gYGBD T05GSUdfRk9PYGAgaXMgZGlzYWJsZWQuCisgKi8KKworLyoqCisgKiBET0M6IEF2b2lkaW5nIHRo ZSBjb2RlIGJpdC1yb3QgcHJvYmxlbSB3aXRoIGxpbmtlciB0YWJsZXMKKyAqCisgKiBMaW5rZXIg dGFibGVzIGNhbiBiZSB1c2VkIHRvIGZ1cnRoZXIgaGVscCBhdm9pZCB0aGUgY29kZSBiaXQtcm90 IHByb2JsZW0KKyAqIHdoZW4gZW1icmFjaW5nIHRoZSAnYnVpbGQtYWxsIHNlbGVjdGl2ZS1saW5r IHBoaWxvc29waHknIGJ5IGxpZnRpbmcgdGhlCisgKiByZXF1aXJlbWVudCB0byB1c2Ugb2YgI2lm ZGVmcyBkdXJpbmcgaW5pdGlhbGl6YXRpb24uIFdpdGggbGlua2VyIHRhYmxlcworICogaW5pdGlh bGl6YXRpb24gc2VxdWVuY2VzIGNhbiBiZSBhZ2dyZWdhdGVkIGludG8gYSBjdXN0b20gRUxGIHNl Y3Rpb24gYXQKKyAqIGxpbmsgdGltZSwgZHVyaW5nIHJ1biB0aW1lIHRoZSB0YWJsZSBjYW4gYmUg aXRlcmF0ZWQgb3ZlciBhbmQgZWFjaCBpbml0CisgKiBzZXF1ZW5jZSBlbmFibGVkIGNhbiBiZSBj YWxsZWQuIEEgZmVhdHVyZSdzIGluaXQgcm91dGluZSBpcyBvbmx5IGFkZGVkIHRvIGEKKyAqIHRh YmxlIHdoZW4gaXRzIHJlc3BlY3RpdmUgS2NvbmZpZyBzeW1ib2xzIGhhcyBiZWVuIGVuYWJsZWQg YW5kIHRoZXJlZm9yZQorICogbGlua2VkIGluLiBMaW5rZXIgdGFibGVzIGVuYWJsZSBzdWJzeXN0 ZW1zIHRvIGNvbXBsZXRlbHkgZG8gYXdheSB3aXRoCisgKiAjaWZkZWZzIGlmIG9uZSBpcyBjb21m b3J0YWJsZSBpbiBhY2NlcHRpbmcgYWxsIHN1YnN5c3RlbSdzIGZlYXR1cmUncworICogc3RydWN0 dXJhbCBzaXplIGltcGxpY2F0aW9ucy4KKyAqCisgKiBUbyBmdXJ0aGVyIGhlbHAgd2l0aCB0aGlz IHRoZSBMaW51eCBidWlsZCBzeXN0ZW0gc3VwcG9ydHMgdHdvIHNwZWNpYWwKKyAqIHRhcmdldHMs IGBgZm9yY2Utb2JqLXlgYCBhbmQgYGBmb3JjZS1saWIteWBgLiBBIHN1YnN5c3RlbSB3aGljaCB3 YW50cyB0bworICogZm9sbG93IHRoZSAnYnVpbGQtYWxsIHNlbGVjdGl2ZS1saW5rIHBoaWxvc29w aHknIGNhbiB1c2UgdGhlc2UgdGFyZ2V0cyBmb3IgYQorICogZmVhdHVyZSdzIGtjb25maWcgc3lt Ym9sLiBVc2luZyB0aGVzZSB0YXJnZXRzIHdpbGwgYWx3YXlzIHJlcXVpcmUKKyAqIGNvbXBpbGF0 aW9uIG9mIHRoZSBrY29uZmlnJ3Mgb2JqZWN0cyBpZiB0aGUga2NvbmZpZyBzeW1ib2wncyBkZXBl bmRlbmNpZXMKKyAqIGFyZSBtZXQgYnV0IG9ubHkgbGluayB0aGUgb2JqZWN0cyBpbnRvIHRoZSBr ZXJuZWwsIGFuZCB0aGVyZWZvcmUgZW5hYmxlIHRoZQorICogZmVhdHVyZSwgaWYgYW5kIG9ubHkg aWYgdGhlIGtjb25maWcgc3ltYm9sIGhhcyBiZWVuIGVuYWJsZWQuCisgKgorICogTm90IGFsbCB1 c2VycyBvciBidWlsZCBzeXN0ZW1zIG1heSB3YW50IHRvIG9wdC1pbiB0byBjb21waWxlIGFsbCBv YmplY3RzCisgKiBmb2xsb3dpbmcgdGhlICdidWlsZC1hbGwgc2VsZWN0aXZlLWxpbmsgcGhpbG9z b3BoeScsIGFzIHN1Y2ggdGhlIHRhcmdldHMKKyAqIGBgZm9yY2Utb2JqLXlgYCBhbmQgYGBmb3Jj ZS1saWIteWBgIG9ubHkgZm9yY2UgY29tcGlsYXRpb24gd2hlbiB0aGUga2NvbmZpZworICogc3lt Ym9sIGBgQ09ORklHX0JVSUxEX0FWT0lEX0JJVFJPVGBgIGhhcyBiZWVuIGVuYWJsZWQuIERpc2Fi bGluZyB0aGlzIGZlYXR1cmUKKyAqIG1ha2VzIGBgZm9yY2Utb2JqLXlgYCBhbmQgYGBmb3JjZS1s aWIteWBgIGZ1bmN0aW9uYWxseSBlcXVpdmFsZW50IHRvCisgKiBgYG9iai15YGAgYW5kIGBgbGli LXlgYCByZXNwZWN0aXZlbHkuCisgKgorICogRXhhbXBsZSB1c2U6OgorICoKKyAqIAlmb3JjZS1v YmotJChDT05GSUdfRkVBVFVSRV9GT08pICs9IGZvby5vCisgKi8KKworLyoqCiAgKiBET0M6IExp bmtlciB0YWJsZSBtb2R1bGUgc3VwcG9ydAogICoKICAqIE1vZHVsZXMgY2FuIHVzZSBsaW5rZXIg dGFibGVzLCBob3dldmVyIHRoZSBsaW5rZXIgdGFibGUgZGVmaW5pdGlvbgpkaWZmIC0tZ2l0IGEv aW5pdC9LY29uZmlnIGIvaW5pdC9LY29uZmlnCmluZGV4IGQwY2FhY2I0YmMxNC4uY2U5MzRlYTZh N2YxIDEwMDY0NAotLS0gYS9pbml0L0tjb25maWcKKysrIGIvaW5pdC9LY29uZmlnCkBAIC02Myw2 ICs2MywyOCBAQCBjb25maWcgQ1JPU1NfQ09NUElMRQogCSAgbmVlZCB0byBzZXQgdGhpcyB1bmxl c3MgeW91IHdhbnQgdGhlIGNvbmZpZ3VyZWQga2VybmVsIGJ1aWxkCiAJICBkaXJlY3RvcnkgdG8g c2VsZWN0IHRoZSBjcm9zcy1jb21waWxlciBhdXRvbWF0aWNhbGx5LgogCitjb25maWcgQlVJTERf QVZPSURfQklUUk9UCisJYm9vbCAiRW5hYmxlIGZvcmNlIGJ1aWxkaW5nIG9mIGZvcmNlLW9iai15 IGFuZCBmb3JjZS1saWIteSIKKwlkZWZhdWx0IG4KKwloZWxwCisJICBXaGVuIGVuYWJsZWQgb2Jq ZWN0cyB1bmRlciB0aGUgZm9yY2Utb2JqLXkgYW5kIGZvcmNlLWxpYi15IHRhcmdldHMKKwkgIHVz aW5nIGEgS2NvbmZpZyBzeW1ib2wgd2lsbCBiZSBmb3JjZWQgdG8gY29tcGlsZSBpZiB0aGUgS2Nv bmZpZworCSAgc3ltYm9sJ3MgZGVwZW5kZW5jaWVzIGFyZSBtZXQgYnV0IG9ubHkgbGlua2VkIGlu dG8gdGhlIGtlcm5lbCBpZgorCSAgdGhlIEtjb25maWcgc3ltYm9sIGlzIGVuYWJsZWQuIElmIGEg S2NvbmZpZyBzeW1ib2wgb24gYSBmb3JjZS1vYmoteQorCSAgb3IgZm9yY2UtbGliLXkgdGFyZ2V0 IGlzIGRpc2FibGVkLCBpdCB3aWxsIGJlIGNvbXBpbGVkIGJ1dCBub3QgbGlua2VkCisJICBpbnRv IHRoZSBrZXJuZWwuCisKKwkgIFRoZSBmb3JjZS1vYmoteSBhbmQgZm9yY2UtbGliLXkgdGFyZ2V0 cyBjYW4gYmUgdXNlZCBieSBzdWJzeXN0ZW1zCisJICB3aGljaCB3aXNoIHRvIHdhbnQgdG8gZm9s bG93IHRoZSAnYnVpbGQtYWxsIHNlbGVjdGl2ZS1saW5rIHBoaWxvc29waHknCisJICBkb2N1bWVu dGVkIHVuZGVyIGluY2x1ZGUvbGludXgvdGFibGVzLmguCisKKwkgIFNheSBZIGlmIHlvdSBoYXZl IGEgZGVjZW50IGJ1aWxkIG1hY2hpbmUgYW5kIHdvdWxkIGxpa2UgdG8gaGVscCB0ZXN0CisJICBi dWlsZGluZyBjb2RlIGZvciBtb3JlIHN1YnN5c3RlbXMuIFNheSBOIGlmIHlvdSBkbyB5b3Ugbm90 IGhhdmUgYQorCSAgZ29vZCBidWlsZCBtYWNoaW5lIG9yIG9ubHkgd2FudCB0byBjb21waWxlIHdo YXQgeW91J3ZlIGVuYWJsZWQgZm9yCisJICB5b3VyIGtlcm5lbC4KKworCSAgRW5hYmxpbmcgdGhp cyBvcHRpb24gbmV2ZXIgaW5jcmVhc2VzIHRoZSBzaXplIG9mIHlvdXIga2VybmVsLgorCiBjb25m aWcgQ09NUElMRV9URVNUCiAJYm9vbCAiQ29tcGlsZSBhbHNvIGRyaXZlcnMgd2hpY2ggd2lsbCBu b3QgbG9hZCIKIAlkZXBlbmRzIG9uICFVTUwKZGlmZiAtLWdpdCBhL3NjcmlwdHMvTWFrZWZpbGUu YnVpbGQgYi9zY3JpcHRzL01ha2VmaWxlLmJ1aWxkCmluZGV4IGVhZGNkNGQzNTlkOS4uYzM0YWY4 MzlkNDdjIDEwMDY0NAotLS0gYS9zY3JpcHRzL01ha2VmaWxlLmJ1aWxkCisrKyBiL3NjcmlwdHMv TWFrZWZpbGUuYnVpbGQKQEAgLTkyLDcgKzkyLDggQEAgbW9kb3JkZXItdGFyZ2V0IDo9ICQob2Jq KS9tb2R1bGVzLm9yZGVyCiAKICMgV2Uga2VlcCBhIGxpc3Qgb2YgYWxsIG1vZHVsZXMgaW4gJChN T0RWRVJESVIpCiAKLV9fYnVpbGQ6ICQoaWYgJChLQlVJTERfQlVJTFRJTiksJChidWlsdGluLXRh cmdldCkgJChsaWItdGFyZ2V0KSAkKGV4dHJhLXkpKSBcCitfX2J1aWxkOiAkKGlmICQoS0JVSUxE X0JVSUxUSU4pLCQoYnVpbHRpbi10YXJnZXQpICQobGliLXRhcmdldCkgJChleHRyYS15KSBcCisJ CQkJJChmb3JjZS1vYmoteSkpIFwKIAkgJChpZiAkKEtCVUlMRF9NT0RVTEVTKSwkKG9iai1tKSAk KG1vZG9yZGVyLXRhcmdldCkpIFwKIAkgJChzdWJkaXIteW0pICQoYWx3YXlzKQogCUA6CkBAIC0z OTIsOCArMzkzLDggQEAgZW5kaWYKICQob2JqKS8lLm86ICQoc3JjKS8lLlMgJChvYmp0b29sX29i aikgRk9SQ0UKIAkkKGNhbGwgaWZfY2hhbmdlZF9ydWxlLGFzX29fUykKIAotdGFyZ2V0cyArPSAk KHJlYWwtb2Jqcy15KSAkKHJlYWwtb2Jqcy1tKSAkKGxpYi15KQotdGFyZ2V0cyArPSAkKGV4dHJh LXkpICQoTUFLRUNNREdPQUxTKSAkKGFsd2F5cykKK3RhcmdldHMgKz0gJChyZWFsLW9ianMteSkg JChyZWFsLW9ianMtbSkgJChsaWIteSkgJChmb3JjZS1saWIteSkKK3RhcmdldHMgKz0gJChleHRy YS15KSAkKGZvcmNlLW9iai15KSAkKE1BS0VDTURHT0FMUykgJChhbHdheXMpCiAKICMgTGlua2Vy IHNjcmlwdHMgcHJlcHJvY2Vzc29yICgubGRzLlMgLT4gLmxkcykKICMgLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tCmRpZmYgLS1naXQgYS9zY3JpcHRzL01ha2VmaWxlLmNsZWFuIGIvc2NyaXB0cy9NYWtlZmls ZS5jbGVhbgppbmRleCA1MDYxNmVhMjUxMzEuLjJiNTQ1NDYyMzdkNiAxMDA2NDQKLS0tIGEvc2Ny aXB0cy9NYWtlZmlsZS5jbGVhbgorKysgYi9zY3JpcHRzL01ha2VmaWxlLmNsZWFuCkBAIC0zNiw2 ICszNiw4IEBAIHN1YmRpci15bW4JOj0gJChhZGRwcmVmaXggJChvYmopLywkKHN1YmRpci15bW4p KQogIyBkaXJlY3RvcnkKIAogX19jbGVhbi1maWxlcwk6PSAkKGV4dHJhLXkpICQoZXh0cmEtbSkg JChleHRyYS0pICAgICAgIFwKKwkJICAgJChmb3JjZS1vYmoteSkgJChmb3JjZS1vYmotbSkgJChm b3JjZS1vYmotKSAgICAgICBcCisJCSAgICQoZm9yY2UtbGliLXkpICQoZm9yY2UtbGliLW0pICQo Zm9yY2UtbGliLSkgICAgICAgXAogCQkgICAkKGFsd2F5cykgJCh0YXJnZXRzKSAkKGNsZWFuLWZp bGVzKSAgIFwKIAkJICAgJChob3N0LXByb2dzKSAgICAgICAgICAgICAgICAgICAgICAgICBcCiAJ CSAgICQoaG9zdHByb2dzLXkpICQoaG9zdHByb2dzLW0pICQoaG9zdHByb2dzLSkgXApkaWZmIC0t Z2l0IGEvc2NyaXB0cy9NYWtlZmlsZS5saWIgYi9zY3JpcHRzL01ha2VmaWxlLmxpYgppbmRleCAw YTA3ZjkwMTQ5NDQuLmQxY2IwY2ZkZjFiZiAxMDA2NDQKLS0tIGEvc2NyaXB0cy9NYWtlZmlsZS5s aWIKKysrIGIvc2NyaXB0cy9NYWtlZmlsZS5saWIKQEAgLTEyLDYgKzEyLDE1IEBAIGV4cG9ydCBL QlVJTERfU1VCRElSX0NDRkxBR1MgOj0gJChLQlVJTERfU1VCRElSX0NDRkxBR1MpICQoc3ViZGly LWNjZmxhZ3MteSkKICMgRmlndXJlIG91dCB3aGF0IHdlIG5lZWQgdG8gYnVpbGQgZnJvbSB0aGUg dmFyaW91cyB2YXJpYWJsZXMKICMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAKK2lmZXEgKCQoQ09ORklH X0JVSUxEX0FWT0lEX0JJVFJPVCkseSkKK2V4dHJhLXkgKz0gJChmb3JjZS1vYmotKSAkKGZvcmNl LWxpYi0pCitlbmRpZgorCitvYmotbSArPSAkKGZvcmNlLW9iai1tKQorb2JqLXkgKz0gJChmb3Jj ZS1vYmoteSkKK2xpYi1tICs9ICQoZm9yY2UtbGliLW0pCitsaWIteSArPSAkKGZvcmNlLWxpYi15 KQorCiAjIFdoZW4gYW4gb2JqZWN0IGlzIGxpc3RlZCB0byBiZSBidWlsdCBjb21waWxlZC1pbiBh bmQgbW9kdWxhciwKICMgb25seSBidWlsZCB0aGUgY29tcGlsZWQtaW4gdmVyc2lvbgogCkBAIC03 Miw2ICs4MSw4IEBAIHJlYWwtb2Jqcy1tIDo9ICQoZm9yZWFjaCBtLCAkKG9iai1tKSwgJChpZiAk KHN0cmlwICQoJChtOi5vPS1vYmpzKSkgJCgkKG06Lm89LXkpCiAjIEFkZCBzdWJkaXIgcGF0aAog CiBleHRyYS15CQk6PSAkKGFkZHByZWZpeCAkKG9iaikvLCQoZXh0cmEteSkpCitmb3JjZS1vYmot eQkJOj0gJChhZGRwcmVmaXggJChvYmopLywkKGZvcmNlLW9iai15KSkKK2ZvcmNlLW9iai1tCQk6 PSAkKGFkZHByZWZpeCAkKG9iaikvLCQoZm9yY2Utb2JqLW0pKQogYWx3YXlzCQk6PSAkKGFkZHBy ZWZpeCAkKG9iaikvLCQoYWx3YXlzKSkKIHRhcmdldHMJCTo9ICQoYWRkcHJlZml4ICQob2JqKS8s JCh0YXJnZXRzKSkKIG1vZG9yZGVyCTo9ICQoYWRkcHJlZml4ICQob2JqKS8sJChtb2RvcmRlcikp Ci0tIAoyLjExLjAKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54ZW4ub3JnCmh0dHBz Oi8vbGlzdHMueGVuLm9yZy94ZW4tZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.kernel.org ([198.145.29.136]:52326 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S968096AbdAIO7M (ORCPT ); Mon, 9 Jan 2017 09:59:12 -0500 From: "Luis R. Rodriguez" Subject: [PATCH v6 05/14] kbuild: enable option to force compile force-obj-y and force-lib-y Date: Mon, 9 Jan 2017 06:58:23 -0800 Message-ID: <20170109145833.11502-6-mcgrof@kernel.org> In-Reply-To: <20170109145833.11502-1-mcgrof@kernel.org> References: <20161222023811.21246-1-mcgrof@kernel.org> <20170109145833.11502-1-mcgrof@kernel.org> Sender: linux-arch-owner@vger.kernel.org List-ID: To: hpa@zytor.com, acme@redhat.com, tglx@linutronix.de, mingo@redhat.com, jpoimboe@redhat.com, bp@alien8.de, npiggin@gmail.com, 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, dalias@libc.org, linux@arm.linux.org.uk Cc: x86@kernel.org, luto@amacapital.net, keescook@chromium.org, linux@roeck-us.net, 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, 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, jolsa@kernel.org, msalter@redhat.com, chris@zankel.net, jcmvbkbc@gmail.com, linux-xtensa@linux-xtensa.org, adrian.hunter@intel.com, dsahern@gmail.com, namhyung@kernel.org, wangnan0@huawei.com, dmitry.torokhov@gmail.com, joro@8bytes.org, paulus@samba.org, mpe@ellerman.id.au, James.Bottomley@HansenPartnership.com, "Luis R. Rodriguez" Message-ID: <20170109145823.NiANLcmUc6muPTffLx0w6GxboCd-z0v568OqlKF26eY@z> 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.clean | 2 + scripts/Makefile.lib | 11 +++++ 7 files changed, 161 insertions(+), 3 deletions(-) diff --git a/Documentation/kbuild/makefiles.txt b/Documentation/kbuild/makefiles.txt index 9b9c4797fc55..1af275cd4879 100644 --- a/Documentation/kbuild/makefiles.txt +++ b/Documentation/kbuild/makefiles.txt @@ -1090,6 +1090,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 780a292d2d00..bc2d9f46cde6 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 1a1838d51951..70a41edfa127 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 d0caacb4bc14..ce934ea6a7f1 100644 --- a/init/Kconfig +++ b/init/Kconfig @@ -63,6 +63,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 eadcd4d359d9..c34af839d47c 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) @: @@ -392,8 +393,8 @@ endif $(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.clean b/scripts/Makefile.clean index 50616ea25131..2b54546237d6 100644 --- a/scripts/Makefile.clean +++ b/scripts/Makefile.clean @@ -36,6 +36,8 @@ subdir-ymn := $(addprefix $(obj)/,$(subdir-ymn)) # directory __clean-files := $(extra-y) $(extra-m) $(extra-) \ + $(force-obj-y) $(force-obj-m) $(force-obj-) \ + $(force-lib-y) $(force-lib-m) $(force-lib-) \ $(always) $(targets) $(clean-files) \ $(host-progs) \ $(hostprogs-y) $(hostprogs-m) $(hostprogs-) \ 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.11.0