В этой теме можете задать вопросы по поводу переноса патчей с одной Agere-модели на другие. Agere-модели Samsung: C120 C130 C140 C160 C170 C200 C200N C210 C230 C240 C250 C260 C300 C400 C520 D100 D410 D520 D800 D830 D840 E210 E300 E310 E400 E530 E570 E600 E610 E620 E710 E720 E770 E790 E810 E840 E850 E860 E870 E880 E900 E910 E950 J600 L310 L320 M300 P100 P300 P310 P400 P710 P730 P900 S100 S200 S300 S300M U100 U300 U600 V200 X120 X140 X150 X160 X200 X210 X300 X400 X430 X450 X461 X480 X481 X510 X520 X530 X610 X630 X660 X680 X800 X810 X820 X830 Для других (Swift и Sysol) моделей есть другая подобная тема: http://OldPh.one/index.php?showtopic=19494 Если вы желаете научиться портировать патчи, то очень желательно, чтобы у вас были навыки программирования. Для начала обязательно прочитайте статью от Artyomcool'а (чтобы увидеть статью, нажмите на кнопку Оффтоп): Перед Вами – статья ознакомительного содержания. В ней будут изложены основные команды THUMB -режима процессора и основные особенности THUMB -программирования. Подразумевается, что вы знакомы с процессом прошивки, со строением прошивки и азами программирования ( Pascal / Delphi , Basic , C / C ++/ C #, Java – любой из этих или других схожих языков). Если вы не знакомы с программированием – это не повод отказываться от патчмэйкинга. Все еще впереди. Я буду стараться излагать известные мне факты наиболее простым и доступным языком, так что даже ребенок сможет научиться писать несложные патчи. Как известно, в THUMB -режиме (далее – тумбе) на одну команду приходится всего два байта. Существует только две команды-исключения: BL и BLX . Но об этом позже. Основой всего программирования можно назвать следующие: регистры, оперативная память (далее – опера), стек и команды. Регистр – область данных, размером в процессорное слово (объем данных, обрабатываемый процессором за один раз). В нашем случае – слово имеет в себе 32 бита (4 байта). Поэтому и в регистре помещается 4 байта данных. Данные принято обозначать в HEX формате. Приемлема и десятичная запись. Перед записью в HEX принято ставить знак “0 x ”, тогда как перед десятичным числом ничего не ставится. Вот примеры (справа – HEX , слева – десятичное значение): 0 x 5=5 0 xA =10 0 x 10=16 0 x 20=32 0xFFFF= 65535 Регистры можно условно разделить на три группы: Младшие регистры – регистры, полностью доступные как в тумбе, так и в ARM . Их всего 8. Обозначаются: R 0, R 1, R 2, …, R 7. Старшие регистры – регистры, полностью доступные только в ARM . Их всего 5. Обозначаются: R 8… R 12. Регистры специального назначения. О них сейчас пойдет отдельный разговор. SP ( R 13) – регистр стека. Всегда установлен на верхушку стека. Подробнее о стеке будет сказано ниже. LR ( R 14) – регистр возврата. Чаще всего используется для возврата из функций. Об этом тоже ниже. PC ( R 15) – регистр позиции кода. В нем находится адрес следующей команды (т.о. если поместить в него адрес, то процессор продолжит свою работу именно с этого нового адреса). CPSR – регистр состояния, или флаговый регистр. В нем содержится много системной информации, такой как режим выполнения ( ARM или тумба) и флаги переходов (об этом – опять же ниже). О стеке. Стек – это кусочек оперативной памяти. Единственная особенность – указатель на этот кусок содержится в SP . Когда мы «передвигаем» указатель стека, мы можем выделять себе определенное количество памяти. Она может понадобиться для размещения локальных переменных, создания небольших локальных буферов и т.п. Чтобы получить доступ к определенной переменной, нам нужен не только указатель стека, но и смещение. К примеру, если в стеке две переменных, то одна находится по адресу [ sp ], другая в [ sp +4].Почему +4, а не +1? Как было сказано выше, размер процессорного слова 4 байта, и поэтому даже под 1 байт информации выделяется аж 4 байта. Квадратные скобки – это обозначения данных (используется для зрительного выделения, чтобы ярко видеть, что мы берем именно значение по адресу в скобках, а не сам адрес). Чтобы передвигать стек нужны команды: Add и Sub . Первая – это прибавить к регистру определенное значение. Вторая – отнять. Имеется несколько вариантов работы с ними: Add SP , N – прибавить к указателю стека N байт ( N кратно 4). Sub SP , N – отнять от указателя стека N байт ( N кратно 4). Add Rx , Ry , N – Rx = Ry + N , N в пределах от 0 до 255 (0 xff ). Sub Rx , Ry , N – Rx = Ry - N , N в пределах от 0 до 255 (0 xff ). Если Rx = Ry можно писать упрощенно: Add Rx, N или Sub Rx, N. Следующий вариант, когда от значения одного регистра надо прибавить (отнять) значение другого: Add Rx, Ry, Rz – Rx=Ry+Rz. Sub Rx, Ry, Rz – Rx=Ry-Rz. Допускается такая запись: Add Rx,Ry – Rx=Rx+Ry. Sub Rx,Ry – Rx=Rx-Ry. Стоит отметить, что эти команды работают только с младшими регистрами (а также с SP , об этом уже было сказано). Бывает, что в регистр надо тупо поместить какое-то число. Существет насколько способов сделать это: 1. Прямое помещение данных: 1.1 Mov Rx , N – поместить в Rx N . 0 1.2 Mov Rx , Ry – поместить в Rx значение Ry . Что характерно, данного варианта для младших регистров просто не существует. Хотя бы один из регистров должен быть старшим (или специальным). Для младших регистров существует подмена: Add rx , ry ,0. Компилятор BinEdit выполняет подмену автоматически, поэтому мы можем смело писать mov r 0, r 1. 2. Чтение данных: 2.1 Ldr Rx , [ Ry + N ] – прочесть 4 байта по адресу Ry + N и поместить их в Rx . Ry и N кратны 4. 2.2 Ldrh Rx , [ Ry + N ] – прочесть 2 байта по адресу Ry + N и поместить их в Rx . Ry и N кратны 2. 2.3 Ldrb Rx , [ Ry + N ] – прочесть 1 байт по адресу Ry + N и поместить его в Rx . Стоит отметить, что если Ry = PC , то PC можно опустить, а вместо PC + N написать непосредственно адрес чтения: Ldr Rx , 0 x 123556. В Rx будет помещено значение по адресу 0 x 123456. Если же написать Ldr Rx , =0 x 123456, то в Rx будет помещено именно 0 x 123456, а не данные по этому адресу. При этом данные 0 x 123456 будут размещены автоматически. Возможно также чтение по сумме регистров, как например в случае Ldr ( h , b ) Rx , [ Ry + Rz ]. Регистры Rx , Ry , Rz – из младшего ряда. В случае Ldr Rx , [ Ry + N ], и только в этом, Ry может быть равен SP и PC . В случае Ldr ( h , b ) Rx , [ Ry + N ] Ry может быть равен PC . Хочется попутно сказать о команде Str ( Strh , Strb ). Эти команды сохраняют регистры по указанному адресу. Принцип работы как и у Ldr(h,. Для перемножения регистров можно использовать команду Mul Rx , Ry . Результат будет записан в Rx . Rx и Ry – младшие регистры. Рассмотрим несколько простых примеров комбинирования данных команд. Задача. Написать функцию, эмулирующею работу формулы a = b * x * x * x + c * y *( y -0 x 100)+ d * z +5000, при чем вернуть результат функция должна в R 0, а данные ей будут переданы следующим образом: R 0= x ; R 1= y ; R2=z; R3=StructAdr. StructAdr – это адрес некой структуры, содержащей в себе параметры b , c и d , причем: [ StructAdr ]= b; [structAdr+4]=c; [structAdr+8]=d; Будем считать, что каждая из переменных занимает 4 байта. ;Подсчитаем x * x * x и сохраним результат в R 0: Mov R 7, R 0 ; Сохраним R 0 в R 7 Mul R 0, R 0 ; Умножим R 0 на само себя Mul R 0, R 7 ; Умножим R 0 на ; Подсчитаем y *( y -0 x 100) и сохраним результат в R 1: Sub R 7, R 1, 0 xFF ; Так как команда Sub имеет ограничение (вычитаемое должно быть Sub R 7, 0 x 1 ; Меньше 256 (0 x 100)), мы вынуждены вычитать дважды. ; Теперь в R7 y-0x100 Mul R 1, R 7 ;Ну и умножили ; Надо считать b , c и d . В R 3 поместим d , в R 4 – c и в R 5 – b . Ldr R5, [R3] ;R5=b Ldr R4, [R3+4] ;R4=c Ldr R3, [R3+8] ;R3=d ; Поместим в R 6 5000 с помощью Ldr : Ldr R6, =5000 ; Вычисляем окончательно: Mul R0, R5 ;R0=b*x*x*x Mul R1, R4 ;R1=c*y*(y-0x100) Mul R2, R3 ;R2=d*z Add R0, R1 ;R0= b*x*x*x+ c*y*(y-0x100) Add R0, R2 ;R0= b*x*x*x+ c*y*(y-0x100)+ d*z Add R0, R6 ;R0= b*x*x*x+c*y*(y-0x100)+d*z+5000 Целиком кусок кода выглядит так: Mov R 7, R 0 Mul R0, R0 Mul R0, R7 Sub R 7, R 1, 0 xFF Sub R 7, 0 x 1 Mul R 1, R 7 Ldr R5, [R3] Ldr R4, [R3+4] Ldr R3, [R3+8] Ldr R6, =5000 Mul R0, R5 Mul R1, R4 Mul R2, R3 Add R0, R1 Add R0, R2 Add R0, R6 . data Как вы, наверное, заметили, символом “;” отделяются комментарии. В конечном варианте была употреблена директива “. data ”, о которой ранее ничего не говорилось. Эта директива указывает на начало области данных – начиная с этого адреса будут размещаться данные, использованные в коде. В данном случае это нужно только для размещения данных «5000». Данный код имеет два минуса: 1. Данный код нельзя вызвать несколько раз – его можно лишь воткнуть непосредственно в код – т.е. данный код не является функцией, хотя выполняет строго определенную задачу. 2. Код изменяет ВСЕ регистры, а нам нужно только изменение в R 0. Для разрешения обеих недоработок нам не хватает команд – команд сохранения регистров в стеке. Строго говоря, можно было бы сохранить регистры по одному, предварительно выделив место в стеке, это будет выглядеть вот так: Sub SP ,32 ;Выделим место под 8 регистров Stmia ! SP { R 0- R 7} ;Сохраняем регистры ;{….} Ldmia ! SP { R 0- R 7} ;Загружаем регистры Add SP,32 ; Восстанавливаем стек Нам встретились две новых команды: Stmia ! Rx {…} – сохранить указанные регистры по адресу в Rx . Ldmia ! Rx {…} – загрузить указанные регистры по адресу в Rx . Регистры можно указывать через запятую или через тире (последнее означает: регистры с … по …), либо комбинировать их: { R 0, R 2, R 6, R 7} { R 1- R 5} { R 0, R 2- R 4, R 6- R 7} { R 0- R 3, R 5, R 7} Регистры обязательно должны следовать в порядке возрастания. Но данный способ здесь не рационален, т.к. существуют команды PUSH и POP : Push {…} – сохраняет указанные регистры в стек, предварительно выделив его. В списке регистров может присутствовать LR (регистр возврата – в него при переходах (точнее вызовах) сохраняется PC , чтобы потом, записав LR в PC , можно было вернуться к предыдущему месту выполнения кода). Pop {…} – загружает регистры из стека и освобождает его. В списке регистров может быть PC . Наша функция должна выглядеть так: Push { R 0- R 7, LR } ;Пока на LR не обращаем внимания. Mov R7, R0 Mul R0, R0 Mul R0, R7 Sub R7, R1, 0xFF Sub R7, 0x1 Mul R1, R7 Ldr R5, [R3] Ldr R4, [R3+4] Ldr R3, [R3+8] Ldr R6, =5000 Mul R0, R5 Mul R1, R4 Mul R2, R3 Add R0, R1 Add R0, R2 Add R0, R6 Pop { R 0- R 7, PC } ;Пока на PC не обращаем внимания. . data Теперь функцию можно вызывать командой BL ( BLX ). BL address – сохранить PC в LR и перейти на указанный адрес. BLX address – сохранить PC в LR и перейти на указанный со сменной режима ( THUMB ARM ). Кардинальным отличием команд BL и BLX является их размер. Вместо двух байт они занимают четыре, даже в THUMB режиме. Механизм работы функций таков: Сохраняем все используемые регистры. Делаем все дела. Загружаем регистры (причем та ячейка стека, в которую мы сохранили LR , восстановится непосредственно в PC ). Все это выглядит вот таким образом: Сохраняем: Push { R 0- R 7, LR } R0 R1 R2 R3 R4 R5 R6 R7 LR Загружаем: Pop { R 0- R 7, PC } R0 R1 R2 R3 R4 R5 R6 R7 PC Бывает, что не все восстанавливается в точности, вот пример: Сохраняем: Push { R 1- R 3, R 7 } R1 R2 R3 R7 Загружаем : Pop {R1,R6,R7,PC} R1 R6 R7 PC В таком случае после выполнения функции исполнение перейдет на адрес, передаваемый функции в R 7. Совет: не меняйте регистры местами (как во второй таблице), дабы избежать непредсказуемых последствий. Хотя это все-таки бывает нужно в исключительных случаях. Как в случае, о котором пойдет речь ниже. Дело в том, что команда BL – относительна. Бывает, что нужно перейти на абсолютный адрес, записав PC в LR и не изменив других регистров. Вот как это делается: Пишем в коде BL callAdress и ставим метку с соответствующей структурой callAdress: Push {R0,R1} ; Сохраним в стек R0,R1 ([sP]=R0, [sP+4]=R1) Ldr r0,=adressToJump ;R0=adressToJump Str r0,[sP+4] ;[sP+4]=R0=adressToJump Pop { R 0, PC } ; R 0= R 0 (вернем в изначальное состояние) и PC = adressToJump Смысл такой структуры заключается в том, что ни один из регистров не меняется (кроме PC , конечно), и получается, что мы просто «перепрыгнули» на adressToJump . Команд, о которых шла речь, вполне достаточно для линейного программирования. Но для полноценного программирования необходимы ветвления. В ассемблере они осуществляются через команды условных и безусловных переходов и команд сравнения. Безусловные переходы: BL , BLX – о них уже говорилось ранее.; B address – переход на address (то же самое, что PC = address ); BX Rx – переход по значению регистра со сменой режима. Режим меняется в зависимости от четности (по значению последнего бита регистра – если последний бит 1, то режим становится THUMB , в противном случае – ARM ). Rx = R 0… PC . Стоит отметить, что из команд безусловных переходов только BX абсолютна. Остальные команды относительны (т.е. если переместить байткод скомпилированной команды по другому адресу, то и ссылаться она будет на другой адрес). Выделяются также и команды условных переходов. Например, мы хотим, чтобы выполняемый код отличался в зависимости от значения какой бы то ни было переменной (или регистра). Как быть? Командами указанными ранее этого добиться трудно (хотя возможно!). Но прежде чем говорить о командах условных переходов, следует упомянуть о регистре состояния и о его битах сравнений (флагах). Как уже упоминалось, в регистре состояния – CPSR – хранится куча «волшебных» битов. Первые пять битов определяют режим. Режим исполнения – очень длинная тема, которая не входит в рамки данной статьи. Шестой бит – бит THUMB режима. Именно его меняет команда BX , и именно этот бит «говорит» процессору в каком режиме идет исполнение и какой набор команд использовать. Следующие два бита – признак канального процесса или передачи данных и признак прерывания. Их назначение, честно говоря, мне не известно. Назначение следующих 20-ти бит неизвестно, наверное, никому, кроме самих корейцев… Хотя, не факт, что их назначение они сами знают J . А вот последние 4 бита регистра состояния использует любой патчмэйкер (правда, не все они об этом знают J ). Эти биты имеют свои обозначения. V – флаг переполнения; C – флаг переноса; Z – флаг нуля; N – флаг отрицательности. Рассмотрим случаи, когда эти флаги меняются. Mov R 0,0 Sub R 0,1 Что произойдет? А произойдет следующие. В R 0 запишется число 0 xFFFFFFFF , как будто бы к R 0 изначально приписали единицу слева. А в бит отрицательности (N) запишется 1. Ldr R0,=0xFFFFFFFF Add R0,1 Что будет в этом случае? А в этом случае в R 0 попадает 0, как будто мы отбрасываем после операций 33-й бит и в бит переполнения ( V ) попадает 1. Очень интересен случай когда: Mov R 0,5 Sub R 0,5 В R 0, ясно дело, попадет 0. А вот в бит нуля ( Z ) попадает 1. Это происходит всегда когда мы вычитаем из регистра его же значение (например, при выполнении команды Mov бит нуля не изменяется, а вот команда Sub меняет его всегда). О бите переноса (С) поговорим в следующих статьях. В пору сказать о командах сравнения – Cmp и Cmn . Cmp Rx , Ry – Rx , Ry от R 0 до R 12; Cmn Rx , Ry – Rx , Ry от R 0 до R 12; Сравнение выполняется презабавным образом. Cmp тупо вычитает из Rx Ry , при этом, сам результат вычисления не сохраняется, а вот флаги сравнения ставятся, как будто мы выполнили команду Sub Rx , Ry . Cmn – то же самое, только ее аналогом является Add , а не Sub . Зачем нужно такое сравнение? А вот зачем. Предположим, Rx = Ry . Тогда при выполнении команды Cmp флаг Z будет равен 1 и мы сможем воспользоваться первым условным переходом – Beq . Beq address – переход если равно ( Z =1); Как пользоваться? Вот пример: ;Функция возвратит в R 0 1, если R 0= R 1. В противном случае, в R 0 вернется 0. Cmp R 0, R 1 ;Сравним Beq Adress 1 ;Если равно, то перейдем на Adress 1 Mov R 0,0 ;Если мы здесь, значит предыдущий Beq не сработал, а значит R 0 R 1 B Exit ; Ну и выйдем… Adress1: Mov R0,1 ; Засунем в R0 1 Exit: BX LR ; Выходим из функции. Иногда бывает удобнее переходить «если не равно». Для этого существует команда Bne (переход осуществляется если Z =0) Что делать, когда помимо равно-неравно необходимо узнать, больше или меньше? Пусть R 0 меньше R 1. Тогда при вычитании из R 0 R 1 в N попадет единица. Команды для работы с N : Bmi – переход если отрицательно ( N =1); Bpl – переход если неотрицательно ( N =0); Пусть, если R 0> R 1, тогда вернем 1, если меньше, то -1 (0 xFFFFFFFF ), а если равны – 0. Cmp R0,R1 Beq address1 Bmi address2 Mov R0,1 BX LR adress1: Mov R0,0 BX LR Adress2: Mov R 0,0 ;Можно конечно использовать Sub R 0,1 ; Ldr R 0,=0 xFFFFFFFF , но это займет больше байт BX LR Таким же образом можно применять следующие команды: BVS - если переполнение разрядов ( V =1) BVC - если нет переполнения разрядов ( V =0) BCS - если больше без учёта знака (если осуществлялся перенос) (с=1) BCC - если меньше без учета знака (если не осуществлялся перенос) (с=0) BHI - если больше без учета знака (c=1, z=0) BLS - если равно или меньше без учёта знака (c=0, z=1) BGE - если больше или равно ((N=1 & V=1) или (N=0 & V=0)) BL T - если меньше ((N=0 & V=1) или (N=1 & V=0)) BLE - меньше или равно (Z=1 и ((V=0 & N=1) или (V=1 & N=0)) BGT - строго больше (Z=0 и ((V=0 & N=1) или (V=1 & N=0)) Подведем итоги. В этой статье я попытался ознакомить вас не столько с программировании на ассемблере, сколько показал его команды. Поэтому, даже обладая знаниями по этим командам, реальные патчи писать пока невозможно. Но в следующей статье я постараюсь научить вас писать простенькие патчи, делая шаг за шагом все необходимое для написания патча. Кроме того, будет подробно рассказано о некоторых директивах компилятора. Вот команды с которыми мы познакомились: Add - прибавление Sub – вычитание Mul – умножение Mov – поместить Ldr – считать Str – записать Ldmia – групповое чтение Stmia – групповая запись Push – сохранение в стек Pop – загрузка из стека B – безусловный переход BX – переход со сменой режима BL – вызов BLX – вызов со сменой режима Cmp – сравнение по – Cmn – сравнение по + Условные переходы: Beq – если равно Bne – если не равно Bmi – переход если отрицательно Bpl – переход если неотрицательно BVS - если переполнение разрядов BVC - если нет переполнения разрядов BCS - если больше без учёта знака BCC - если меньше без учета знака BHI - если больше без учета знака BLS - если равно или меньше без учёта знака BGE - если больше или равно BL T - если меньше BLE - меньше или равно BGT - строго больше
