write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/arch/sh/kernel/disassemble.c
..
..
@@ -1,12 +1,9 @@
1
+// SPDX-License-Identifier: GPL-2.0
1
2
 /*
2
3
  * Disassemble SuperH instructions.
3
4
  *
4
5
  * Copyright (C) 1999 kaz Kojima
5
6
  * Copyright (C) 2008 Paul Mundt
6
- *
7
- * This file is subject to the terms and conditions of the GNU General Public
8
- * License.  See the file "COPYING" in the main directory of this archive
9
- * for more details.
10
7
  */
11
8
 #include <linux/kernel.h>
12
9
 #include <linux/string.h>
..
..
@@ -379,149 +376,148 @@
379
376
 		}
380
377
 
381
378
 	ok:
382
-		printk("%-8s  ", op->name);
379
+		pr_cont("%-8s  ", op->name);
383
380
 		lastsp = (op->arg[0] == A_END);
384
381
 		disp_pc = 0;
385
382
 		for (n = 0; n < 6 && op->arg[n] != A_END; n++) {
386
383
 			if (n && op->arg[1] != A_END)
387
-				printk(", ");
384
+				pr_cont(", ");
388
385
 			switch (op->arg[n]) {
389
386
 			case A_IMM:
390
-				printk("#%d", (char)(imm));
387
+				pr_cont("#%d", (char)(imm));
391
388
 				break;
392
389
 			case A_R0:
393
-				printk("r0");
390
+				pr_cont("r0");
394
391
 				break;
395
392
 			case A_REG_N:
396
-				printk("r%d", rn);
393
+				pr_cont("r%d", rn);
397
394
 				break;
398
395
 			case A_INC_N:
399
-				printk("@r%d+", rn);
396
+				pr_cont("@r%d+", rn);
400
397
 				break;
401
398
 			case A_DEC_N:
402
-				printk("@-r%d", rn);
399
+				pr_cont("@-r%d", rn);
403
400
 				break;
404
401
 			case A_IND_N:
405
-				printk("@r%d", rn);
402
+				pr_cont("@r%d", rn);
406
403
 				break;
407
404
 			case A_DISP_REG_N:
408
-				printk("@(%d,r%d)", imm, rn);
405
+				pr_cont("@(%d,r%d)", imm, rn);
409
406
 				break;
410
407
 			case A_REG_M:
411
-				printk("r%d", rm);
408
+				pr_cont("r%d", rm);
412
409
 				break;
413
410
 			case A_INC_M:
414
-				printk("@r%d+", rm);
411
+				pr_cont("@r%d+", rm);
415
412
 				break;
416
413
 			case A_DEC_M:
417
-				printk("@-r%d", rm);
414
+				pr_cont("@-r%d", rm);
418
415
 				break;
419
416
 			case A_IND_M:
420
-				printk("@r%d", rm);
417
+				pr_cont("@r%d", rm);
421
418
 				break;
422
419
 			case A_DISP_REG_M:
423
-				printk("@(%d,r%d)", imm, rm);
420
+				pr_cont("@(%d,r%d)", imm, rm);
424
421
 				break;
425
422
 			case A_REG_B:
426
-				printk("r%d_bank", rb);
423
+				pr_cont("r%d_bank", rb);
427
424
 				break;
428
425
 			case A_DISP_PC:
429
426
 				disp_pc = 1;
430
427
 				disp_pc_addr = imm + 4 + (memaddr & relmask);
431
-				printk("%08x <%pS>", disp_pc_addr,
432
-				       (void *)disp_pc_addr);
428
+				pr_cont("%08x <%pS>", disp_pc_addr,
429
+					(void *)disp_pc_addr);
433
430
 				break;
434
431
 			case A_IND_R0_REG_N:
435
-				printk("@(r0,r%d)", rn);
432
+				pr_cont("@(r0,r%d)", rn);
436
433
 				break;
437
434
 			case A_IND_R0_REG_M:
438
-				printk("@(r0,r%d)", rm);
435
+				pr_cont("@(r0,r%d)", rm);
439
436
 				break;
440
437
 			case A_DISP_GBR:
441
-				printk("@(%d,gbr)",imm);
438
+				pr_cont("@(%d,gbr)", imm);
442
439
 				break;
443
440
 			case A_R0_GBR:
444
-				printk("@(r0,gbr)");
441
+				pr_cont("@(r0,gbr)");
445
442
 				break;
446
443
 			case A_BDISP12:
447
444
 			case A_BDISP8:
448
-				printk("%08x", imm + memaddr);
445
+				pr_cont("%08x", imm + memaddr);
449
446
 				break;
450
447
 			case A_SR:
451
-				printk("sr");
448
+				pr_cont("sr");
452
449
 				break;
453
450
 			case A_GBR:
454
-				printk("gbr");
451
+				pr_cont("gbr");
455
452
 				break;
456
453
 			case A_VBR:
457
-				printk("vbr");
454
+				pr_cont("vbr");
458
455
 				break;
459
456
 			case A_SSR:
460
-				printk("ssr");
457
+				pr_cont("ssr");
461
458
 				break;
462
459
 			case A_SPC:
463
-				printk("spc");
460
+				pr_cont("spc");
464
461
 				break;
465
462
 			case A_MACH:
466
-				printk("mach");
463
+				pr_cont("mach");
467
464
 				break;
468
465
 			case A_MACL:
469
-				printk("macl");
466
+				pr_cont("macl");
470
467
 				break;
471
468
 			case A_PR:
472
-				printk("pr");
469
+				pr_cont("pr");
473
470
 				break;
474
471
 			case A_SGR:
475
-				printk("sgr");
472
+				pr_cont("sgr");
476
473
 				break;
477
474
 			case A_DBR:
478
-				printk("dbr");
475
+				pr_cont("dbr");
479
476
 				break;
480
477
 			case FD_REG_N:
481
-				if (0)
482
-					goto d_reg_n;
483
478
 			case F_REG_N:
484
-				printk("fr%d", rn);
479
+				pr_cont("fr%d", rn);
485
480
 				break;
486
481
 			case F_REG_M:
487
-				printk("fr%d", rm);
482
+				pr_cont("fr%d", rm);
488
483
 				break;
489
484
 			case DX_REG_N:
490
485
 				if (rn & 1) {
491
-					printk("xd%d", rn & ~1);
486
+					pr_cont("xd%d", rn & ~1);
492
487
 					break;
493
488
 				}
494
-			d_reg_n:
489
+				fallthrough;
495
490
 			case D_REG_N:
496
-				printk("dr%d", rn);
491
+				pr_cont("dr%d", rn);
497
492
 				break;
498
493
 			case DX_REG_M:
499
494
 				if (rm & 1) {
500
-					printk("xd%d", rm & ~1);
495
+					pr_cont("xd%d", rm & ~1);
501
496
 					break;
502
497
 				}
498
+				fallthrough;
503
499
 			case D_REG_M:
504
-				printk("dr%d", rm);
500
+				pr_cont("dr%d", rm);
505
501
 				break;
506
502
 			case FPSCR_M:
507
503
 			case FPSCR_N:
508
-				printk("fpscr");
504
+				pr_cont("fpscr");
509
505
 				break;
510
506
 			case FPUL_M:
511
507
 			case FPUL_N:
512
-				printk("fpul");
508
+				pr_cont("fpul");
513
509
 				break;
514
510
 			case F_FR0:
515
-				printk("fr0");
511
+				pr_cont("fr0");
516
512
 				break;
517
513
 			case V_REG_N:
518
-				printk("fv%d", rn*4);
514
+				pr_cont("fv%d", rn*4);
519
515
 				break;
520
516
 			case V_REG_M:
521
-				printk("fv%d", rm*4);
517
+				pr_cont("fv%d", rm*4);
522
518
 				break;
523
519
 			case XMTRX_M4:
524
-				printk("xmtrx");
520
+				pr_cont("xmtrx");
525
521
 				break;
526
522
 			default:
527
523
 				return;
..
..
@@ -536,7 +532,7 @@
536
532
 			else
537
533
 				__get_user(val, (u32 *)disp_pc_addr);
538
534
 
539
-			printk("  ! %08x <%pS>", val, (void *)val);
535
+			pr_cont("  ! %08x <%pS>", val, (void *)val);
540
536
 		}
541
537
 
542
538
 		return;
..
..
@@ -545,7 +541,7 @@
545
541
 
546
542
 	}
547
543
 
548
-	printk(".word 0x%x%x%x%x", nibs[0], nibs[1], nibs[2], nibs[3]);
544
+	pr_info(".word 0x%x%x%x%x", nibs[0], nibs[1], nibs[2], nibs[3]);
549
545
 }
550
546
 
551
547
 void show_code(struct pt_regs *regs)
..
..
@@ -556,20 +552,21 @@
556
552
 	if (regs->pc & 0x1)
557
553
 		return;
558
554
 
559
-	printk("Code:\n");
555
+	pr_info("Code:\n");
560
556
 
561
557
 	for (i = -3 ; i < 6 ; i++) {
562
558
 		unsigned short insn;
563
559
 
564
560
 		if (__get_user(insn, pc + i)) {
565
-			printk(" (Bad address in pc)\n");
561
+			pr_err(" (Bad address in pc)\n");
566
562
 			break;
567
563
 		}
568
564
 
569
-		printk("%s%08lx:  ", (i ? "  ": "->"), (unsigned long)(pc + i));
565
+		pr_info("%s%08lx:  ", (i ? "  " : "->"),
566
+			(unsigned long)(pc + i));
570
567
 		print_sh_insn((unsigned long)(pc + i), insn);
571
-		printk("\n");
568
+		pr_cont("\n");
572
569
 	}
573
570
 
574
-	printk("\n");
571
+	pr_info("\n");
575
572
 }