leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

efi/printf: Add 64-bit and 8-bit integer support

Browse Source 
Support 'll' qualifier for long long by copying the decimal printing
code from lib/vsprintf.c. For simplicity, the 32-bit code is used on
64-bit architectures as well.

Support 'hh' qualifier for signed/unsigned char type integers.

Signed-off-by: Arvind Sankar <nivedita@alum.mit.edu>
Link: https://lore.kernel.org/r/20200518190716.751506-8-nivedita@alum.mit.edu
Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
This commit is contained in:
Arvind Sankar 2020-05-18 15:06:59 -04:00 committed by Ard Biesheuvel
parent 29a2806653
commit ce5e3f909f
1 changed files with 143 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

170
drivers/firmware/efi/libstub/vsprintf.c
View File

@ -7,10 +7,7 @@
* ----------------------------------------------------------------------- */ * ----------------------------------------------------------------------- */
/* /*
* Oh, it's a waste of space, but oh-so-yummy for debugging. This * Oh, it's a waste of space, but oh-so-yummy for debugging.
* version of printf() does not include 64-bit support. "Live with
* it."
*
*/ */
#include <stdarg.h> #include <stdarg.h>
@ -28,6 +25,86 @@ static int skip_atoi(const char **s)
return i; return i;
} }
/*
* put_dec_full4 handles numbers in the range 0 <= r < 10000.
* The multiplier 0xccd is round(2^15/10), and the approximation
* r/10 == (r * 0xccd) >> 15 is exact for all r < 16389.
*/
static
void put_dec_full4(char *buf, unsigned int r)
{
int i;
for (i = 0; i < 3; i++) {
unsigned int q = (r * 0xccd) >> 15;
*buf++ = '0' + (r - q * 10);
r = q;
}
*buf++ = '0' + r;
}
/* put_dec is copied from lib/vsprintf.c with small modifications */
/*
* Call put_dec_full4 on x % 10000, return x / 10000.
* The approximation x/10000 == (x * 0x346DC5D7) >> 43
* holds for all x < 1,128,869,999. The largest value this
* helper will ever be asked to convert is 1,125,520,955.
* (second call in the put_dec code, assuming n is all-ones).
*/
static
unsigned int put_dec_helper4(char *buf, unsigned int x)
{
unsigned int q = (x * 0x346DC5D7ULL) >> 43;
put_dec_full4(buf, x - q * 10000);
return q;
}
/* Based on code by Douglas W. Jones found at
* <http://www.cs.uiowa.edu/~jones/bcd/decimal.html#sixtyfour>
* (with permission from the author).
* Performs no 64-bit division and hence should be fast on 32-bit machines.
*/
static
int put_dec(char *buf, unsigned long long n)
{
unsigned int d3, d2, d1, q, h;
char *p = buf;
d1 = ((unsigned int)n >> 16); /* implicit "& 0xffff" */
h = (n >> 32);
d2 = (h ) & 0xffff;
d3 = (h >> 16); /* implicit "& 0xffff" */
/* n = 2^48 d3 + 2^32 d2 + 2^16 d1 + d0
= 281_4749_7671_0656 d3 + 42_9496_7296 d2 + 6_5536 d1 + d0 */
q = 656 * d3 + 7296 * d2 + 5536 * d1 + ((unsigned int)n & 0xffff);
q = put_dec_helper4(p, q);
p += 4;
q += 7671 * d3 + 9496 * d2 + 6 * d1;
q = put_dec_helper4(p, q);
p += 4;
q += 4749 * d3 + 42 * d2;
q = put_dec_helper4(p, q);
p += 4;
q += 281 * d3;
q = put_dec_helper4(p, q);
p += 4;
put_dec_full4(p, q);
p += 4;
/* strip off the extra 0's we printed */
while (p > buf && p[-1] == '0')
--p;
return p - buf;
}
#define ZEROPAD 1 /* pad with zero */ #define ZEROPAD 1 /* pad with zero */
#define SIGN 2 /* unsigned/signed long */ #define SIGN 2 /* unsigned/signed long */
#define PLUS 4 /* show plus */ #define PLUS 4 /* show plus */
@ -36,13 +113,7 @@ static int skip_atoi(const char **s)
#define SMALL 32 /* Must be 32 == 0x20 */ #define SMALL 32 /* Must be 32 == 0x20 */
#define SPECIAL 64 /* 0x */ #define SPECIAL 64 /* 0x */
#define __do_div(n, base) ({ \ static char *number(char *str, long long num, int base, int size, int precision,
int __res; \
__res = ((unsigned long) n) % (unsigned) base; \
n = ((unsigned long) n) / (unsigned) base; \
__res; })
static char *number(char *str, long num, int base, int size, int precision,
int type) int type)
{ {
/* we are called with base 8, 10 or 16, only, thus don't need "G..." */ /* we are called with base 8, 10 or 16, only, thus don't need "G..." */
@ -57,8 +128,6 @@ static char *number(char *str, long num, int base, int size, int precision,
locase = (type & SMALL); locase = (type & SMALL);
if (type & LEFT) if (type & LEFT)
type &= ~ZEROPAD; type &= ~ZEROPAD;
if (base < 2 || base > 16)
return NULL;
c = (type & ZEROPAD) ? '0' : ' '; c = (type & ZEROPAD) ? '0' : ' ';
sign = 0; sign = 0;
if (type & SIGN) { if (type & SIGN) {
@ -83,9 +152,28 @@ static char *number(char *str, long num, int base, int size, int precision,
i = 0; i = 0;
if (num == 0) if (num == 0)
tmp[i++] = '0'; tmp[i++] = '0';
else else {
while (num != 0) switch (base) {
tmp[i++] = (digits[__do_div(num, base)] | locase); case 10:
i += put_dec(&tmp[i], num);
break;
case 8:
while (num != 0) {
tmp[i++] = '0' + (num & 07);
num = (unsigned long long)num >> 3;
}
break;
case 16:
while (num != 0) {
tmp[i++] = digits[num & 0xf] | locase;
num = (unsigned long long)num >> 4;
}
break;
default:
unreachable();
}
}
if (i > precision) if (i > precision)
precision = i; precision = i;
size -= precision; size -= precision;
@ -117,7 +205,7 @@ static char *number(char *str, long num, int base, int size, int precision,
int vsprintf(char *buf, const char *fmt, va_list args) int vsprintf(char *buf, const char *fmt, va_list args)
{ {
int len; int len;
unsigned long num; unsigned long long num;
int i, base; int i, base;
char *str; char *str;
const char *s; const char *s;
@ -127,7 +215,7 @@ int vsprintf(char *buf, const char *fmt, va_list args)
int field_width; /* width of output field */ int field_width; /* width of output field */
int precision; /* min. # of digits for integers; max int precision; /* min. # of digits for integers; max
number of chars for from string */ number of chars for from string */
int qualifier; /* 'h' or 'l' for integer fields */ int qualifier; /* 'h', 'hh', 'l' or 'll' for integer fields */
for (str = buf; *fmt; ++fmt) { for (str = buf; *fmt; ++fmt) {
if (*fmt != '%') { if (*fmt != '%') {
@ -191,6 +279,10 @@ int vsprintf(char *buf, const char *fmt, va_list args)
if (*fmt == 'h' || *fmt == 'l') { if (*fmt == 'h' || *fmt == 'l') {
qualifier = *fmt; qualifier = *fmt;
++fmt; ++fmt;
if (qualifier == *fmt) {
qualifier -= 'a'-'A';
++fmt;
}
} }
/* default base */ /* default base */
@ -260,16 +352,40 @@ int vsprintf(char *buf, const char *fmt, va_list args)
--fmt; --fmt;
continue; continue;
} }
if (qualifier == 'l') { if (flags & SIGN) {
num = va_arg(args, unsigned long); switch (qualifier) {
} else if (qualifier == 'h') { case 'L':
num = (unsigned short)va_arg(args, int); num = va_arg(args, long long);
if (flags & SIGN) break;
num = (short)num; case 'l':
} else if (flags & SIGN) { num = va_arg(args, long);
num = va_arg(args, int); break;
case 'h':
num = (short)va_arg(args, int);
break;
case 'H':
num = (signed char)va_arg(args, int);
break;
default:
num = va_arg(args, int);
}
} else { } else {
num = va_arg(args, unsigned int); switch (qualifier) {
case 'L':
num = va_arg(args, unsigned long long);
break;
case 'l':
num = va_arg(args, unsigned long);
break;
case 'h':
num = (unsigned short)va_arg(args, int);
break;
case 'H':
num = (unsigned char)va_arg(args, int);
break;
default:
num = va_arg(args, unsigned int);
}
} }
str = number(str, num, base, field_width, precision, flags); str = number(str, num, base, field_width, precision, flags);
} }